@sentry/junior 0.203.0 → 0.205.0

package/dist/chunk-N7TMSOZH.js

@@ -1,235 +0,0 @@
-// src/chat/slack/timestamp.ts
-import { z } from "zod";
-var slackMessageTsSchema = z.string().trim().regex(/^\d+(?:\.\d+)?$/).brand();
-function parseSlackMessageTs(value) {
-  const parsed = slackMessageTsSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
-}
-
-// src/chat/slack/ids.ts
-import { z as z2 } from "zod";
-var slackChannelIdSchema = z2.string().regex(/^[CDG][A-Z0-9]+$/).brand();
-var slackTeamIdSchema = z2.string().regex(/^T[A-Z0-9]+$/).brand();
-var slackUserIdSchema = z2.string().regex(/^[UW][A-Z0-9]+$/).brand();
-var SLACK_CHANNEL_MENTION_RE = /^<#([CDG][A-Z0-9]+)(?:\|[^>]*)?>$/;
-function slackChannelReferenceCandidate(value) {
-  const trimmed = value.trim();
-  if (!trimmed.startsWith("slack:")) {
-    return trimmed;
-  }
-  const parts = trimmed.split(":");
-  if (parts.length === 2) {
-    return parts[1]?.trim() ?? "";
-  }
-  if (parts.length === 3 && parseSlackMessageTs(parts[2])) {
-    return parts[1]?.trim() ?? "";
-  }
-  return "";
-}
-function parseSlackChannelId(value) {
-  if (typeof value !== "string") return void 0;
-  const parsed = slackChannelIdSchema.safeParse(value.trim());
-  return parsed.success ? parsed.data : void 0;
-}
-function parseSlackChannelReferenceId(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  const mentionMatch = SLACK_CHANNEL_MENTION_RE.exec(trimmed);
-  if (mentionMatch?.[1]) {
-    return parseSlackChannelId(mentionMatch[1]);
-  }
-  return parseSlackChannelId(slackChannelReferenceCandidate(trimmed));
-}
-function parseSlackTeamId(value) {
-  if (typeof value !== "string") return void 0;
-  const parsed = slackTeamIdSchema.safeParse(value.trim());
-  return parsed.success ? parsed.data : void 0;
-}
-function parseSlackUserId(value) {
-  if (typeof value !== "string") return void 0;
-  const parsed = slackUserIdSchema.safeParse(value.trim());
-  return parsed.success ? parsed.data : void 0;
-}
-
-// src/chat/actor.ts
-import { z as z3 } from "zod";
-import { actorSchema } from "@sentry/junior-plugin-api";
-var SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
-var EMAIL_PATTERN = /^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/;
-var exactStoredStringSchema = z3.string().min(1).refine((value) => value === value.trim());
-var storedSlackActorSchema = z3.object({
-  email: exactStoredStringSchema.optional(),
-  fullName: exactStoredStringSchema.optional(),
-  platform: z3.literal("slack").optional(),
-  slackUserId: exactStoredStringSchema.optional(),
-  slackUserName: exactStoredStringSchema.optional(),
-  teamId: exactStoredStringSchema.optional()
-}).strict();
-function isUserActor(actor) {
-  return Boolean(actor && "userId" in actor);
-}
-function clean(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
-}
-function isSyntheticActorUserId(value) {
-  return value.toLowerCase() === "unknown";
-}
-function isSlackUserId(value) {
-  return SLACK_USER_ID_DISPLAY_PATTERN.test(value);
-}
-function cleanActorDisplayName(value, userId) {
-  const displayName = clean(value);
-  if (!displayName) {
-    return void 0;
-  }
-  if (displayName.toLowerCase() === "unknown") {
-    return void 0;
-  }
-  if (userId && displayName === userId) {
-    return void 0;
-  }
-  return isSlackUserId(displayName) ? void 0 : displayName;
-}
-function cleanActorEmail(value) {
-  const email = clean(value);
-  return email && EMAIL_PATTERN.test(email) ? email : void 0;
-}
-function parseActorUserId(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return void 0;
-  }
-  if (value !== value.trim() || isSyntheticActorUserId(value)) {
-    return void 0;
-  }
-  return value;
-}
-function isActorUserId(value) {
-  return parseActorUserId(value) === value;
-}
-function createActor(input, context) {
-  const platform = context.platform ?? input?.platform;
-  if (!platform) {
-    return void 0;
-  }
-  const contextUserId = parseActorUserId(context.userId);
-  if (context.userId !== void 0 && !contextUserId) {
-    return void 0;
-  }
-  const inputUserId = parseActorUserId(input?.userId);
-  if (input?.userId !== void 0 && !inputUserId) {
-    return void 0;
-  }
-  const actorUserId = contextUserId ?? inputUserId;
-  if (!actorUserId) {
-    return void 0;
-  }
-  const contextTeamId = parseSlackTeamId(context.teamId);
-  if (context.teamId !== void 0 && !contextTeamId) {
-    return void 0;
-  }
-  const inputTeamId = parseSlackTeamId(input?.teamId);
-  if (input?.teamId !== void 0 && !inputTeamId) {
-    return void 0;
-  }
-  const actorTeamId = contextTeamId ?? inputTeamId;
-  if (platform === "slack" && !actorTeamId) {
-    return void 0;
-  }
-  const canUseInputProfile = (!contextUserId || !inputUserId || contextUserId === inputUserId) && (platform !== "slack" || !contextTeamId || !inputTeamId || contextTeamId === inputTeamId);
-  const actor = {
-    ...canUseInputProfile && cleanActorEmail(input?.email) ? { email: cleanActorEmail(input?.email) } : void 0,
-    ...canUseInputProfile && cleanActorDisplayName(input?.fullName, actorUserId) ? {
-      fullName: cleanActorDisplayName(input?.fullName, actorUserId)
-    } : void 0,
-    platform,
-    userId: actorUserId,
-    ...canUseInputProfile && cleanActorDisplayName(input?.userName, actorUserId) ? {
-      userName: cleanActorDisplayName(input?.userName, actorUserId)
-    } : void 0
-  };
-  if (platform === "slack") {
-    return { ...actor, platform, teamId: actorTeamId };
-  }
-  return { ...actor, platform };
-}
-function createSlackActor(teamId, userId, profile) {
-  const actorUserId = parseActorUserId(userId);
-  const actorTeamId = parseSlackTeamId(teamId);
-  if (!actorTeamId || !actorUserId) {
-    throw new Error("Slack actor requires team and user ids");
-  }
-  const actor = createActor(
-    {
-      email: profile?.email,
-      fullName: profile?.fullName,
-      platform: "slack",
-      teamId: actorTeamId,
-      userId: actorUserId,
-      userName: profile?.userName
-    },
-    { teamId: actorTeamId, userId: actorUserId }
-  );
-  if (!actor || actor.platform !== "slack") {
-    throw new Error("Slack actor requires team and user ids");
-  }
-  return actor;
-}
-function parseStoredSlackActor(value) {
-  const parsed = storedSlackActorSchema.safeParse(value);
-  if (!parsed.success) {
-    return void 0;
-  }
-  if (parsed.data.slackUserId !== void 0 && !parseActorUserId(parsed.data.slackUserId)) {
-    return void 0;
-  }
-  if (parsed.data.teamId !== void 0 && !parseSlackTeamId(parsed.data.teamId)) {
-    return void 0;
-  }
-  if ((parsed.data.platform !== void 0 || parsed.data.teamId !== void 0) && (!parsed.data.platform || !parsed.data.teamId)) {
-    return void 0;
-  }
-  return parsed.data;
-}
-function toStoredSlackActor(actor) {
-  return {
-    ...actor.email ? { email: actor.email } : void 0,
-    ...actor.fullName ? { fullName: actor.fullName } : void 0,
-    platform: actor.platform,
-    slackUserId: actor.userId,
-    ...actor.userName ? { slackUserName: actor.userName } : void 0,
-    teamId: actor.teamId
-  };
-}
-function createSlackResumeActor(args) {
-  if (args.actor) {
-    if (args.actor.platform !== "slack" || args.actor.teamId !== args.teamId || args.actor.userId !== args.userId) {
-      throw new Error("Stored Slack actor did not match resume actor");
-    }
-  }
-  const actor = createActor(args.actor, {
-    platform: "slack",
-    teamId: args.teamId,
-    userId: args.userId
-  });
-  if (!actor || actor.platform !== "slack") {
-    throw new Error("Slack actor requires team and user ids");
-  }
-  return actor;
-}
-
-export {
-  parseSlackMessageTs,
-  parseSlackChannelId,
-  parseSlackChannelReferenceId,
-  parseSlackTeamId,
-  parseSlackUserId,
-  isUserActor,
-  parseActorUserId,
-  isActorUserId,
-  createActor,
-  createSlackActor,
-  parseStoredSlackActor,
-  toStoredSlackActor,
-  createSlackResumeActor
-};

package/dist/chunk-NCEBK6PH.js

@@ -1,36 +0,0 @@
-import {
-  FUNCTION_TIMEOUT_BUFFER_SECONDS,
-  getChatConfig
-} from "./chunk-ENY6SKIU.js";
-
-// src/chat/runtime/request-deadline.ts
-import { AsyncLocalStorage } from "async_hooks";
-var requestDeadlineStorage = new AsyncLocalStorage();
-function createTurnRequestDeadline(startedAtMs) {
-  const requestBudgetMs = Math.max(
-    1,
-    getChatConfig().functionMaxDurationSeconds * 1e3 - FUNCTION_TIMEOUT_BUFFER_SECONDS * 1e3
-  );
-  return {
-    startedAtMs,
-    deadlineAtMs: startedAtMs + requestBudgetMs
-  };
-}
-function getTurnRequestDeadline() {
-  return requestDeadlineStorage.getStore();
-}
-function runWithTurnRequestDeadline(callback, startedAtMs = Date.now()) {
-  const existingDeadline = requestDeadlineStorage.getStore();
-  if (existingDeadline) {
-    return callback();
-  }
-  return requestDeadlineStorage.run(
-    createTurnRequestDeadline(startedAtMs),
-    callback
-  );
-}
-
-export {
-  getTurnRequestDeadline,
-  runWithTurnRequestDeadline
-};

package/dist/chunk-NHJU2ZAL.js

@@ -1,56 +0,0 @@
-// src/chat/reasoning-level.ts
-import { z } from "zod";
-var TURN_REASONING_LEVELS = [
-  "none",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-function parseTurnReasoningLevel(value) {
-  return z.enum(TURN_REASONING_LEVELS).parse(value);
-}
-
-// src/chat/model-profile.ts
-import { z as z2 } from "zod";
-var modelProfileSchema = z2.string().regex(/^[a-z][a-z0-9_-]*$/);
-function formatModelProfile(profile, description) {
-  const text = description?.trim();
-  return text ? `"${profile}": ${text}` : `"${profile}"`;
-}
-function formatModelProfiles(profiles, profileNames) {
-  return profileNames.map(
-    (profile) => `- ${formatModelProfile(profile, profiles[profile]?.description)}`
-  ).join("\n");
-}
-var ModelProfileNotConfiguredError = class extends Error {
-  constructor(profile) {
-    super(`Model profile "${profile}" is not configured`);
-    this.name = "ModelProfileNotConfiguredError";
-  }
-};
-function modelIdForProfile(config, profile) {
-  return profileConfig(config, profile).modelId;
-}
-function defaultModelId(config) {
-  return modelIdForProfile(config, config.defaultProfile);
-}
-function profileConfig(config, profile) {
-  const profileConfig2 = Object.hasOwn(config.profiles, profile) ? config.profiles[profile] : void 0;
-  if (!profileConfig2) {
-    throw new ModelProfileNotConfiguredError(profile);
-  }
-  return profileConfig2;
-}
-
-export {
-  TURN_REASONING_LEVELS,
-  parseTurnReasoningLevel,
-  modelProfileSchema,
-  formatModelProfile,
-  formatModelProfiles,
-  ModelProfileNotConfiguredError,
-  modelIdForProfile,
-  defaultModelId,
-  profileConfig
-};

package/dist/chunk-P6KTRNVC.js

@@ -1,321 +0,0 @@
-import {
-  getChatConfig
-} from "./chunk-ENY6SKIU.js";
-
-// src/chat/state/adapter.ts
-import { createMemoryState } from "@chat-adapter/state-memory";
-import { createRedisState } from "@chat-adapter/state-redis";
-
-// src/chat/state/locks.ts
-import { setTimeout as sleep } from "timers/promises";
-var ACTIVE_LOCK_TTL_MS = 9e4;
-var MUTATION_LOCK_TTL_MS = 1e4;
-async function acquireActiveLock(state, threadId) {
-  return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
-}
-async function withLock(state, key, run, options = {}) {
-  const startedAtMs = Date.now();
-  let lock;
-  while (true) {
-    lock = await state.acquireLock(key, options.ttlMs ?? ACTIVE_LOCK_TTL_MS);
-    if (lock) break;
-    if (Date.now() - startedAtMs >= (options.waitMs ?? 0)) {
-      return { acquired: false };
-    }
-    await sleep(options.retryMs ?? 25, void 0, { ref: false });
-  }
-  const ttlMs = options.ttlMs ?? ACTIVE_LOCK_TTL_MS;
-  const heartbeat = options.keepAlive ? setInterval(
-    () => {
-      void state.extendLock(lock, ttlMs);
-    },
-    Math.max(1, Math.floor(ttlMs / 3))
-  ) : void 0;
-  heartbeat?.unref();
-  try {
-    return { acquired: true, value: await run(lock) };
-  } finally {
-    if (heartbeat) clearInterval(heartbeat);
-    await state.releaseLock(lock);
-  }
-}
-async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
-  if (!await state.extendLock(lock, ttlMs)) {
-    throw new Error(
-      `Lock ownership was lost before write for ${lock.threadId}`
-    );
-  }
-}
-async function withActiveLock(state, key, run) {
-  return await withLock(state, key, run);
-}
-
-// src/chat/state/adapter.ts
-var ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
-var stateAdapter;
-var redisStateAdapter;
-function createConnectingStateAdapter(base) {
-  const connected = async (operation) => {
-    await base.connect();
-    return await operation();
-  };
-  return {
-    appendToList: (key, value, options) => connected(() => base.appendToList(key, value, options)),
-    connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
-    subscribe: (threadId) => connected(() => base.subscribe(threadId)),
-    unsubscribe: (threadId) => connected(() => base.unsubscribe(threadId)),
-    isSubscribed: (threadId) => connected(() => base.isSubscribed(threadId)),
-    acquireLock: (threadId, ttlMs) => connected(() => base.acquireLock(threadId, ttlMs)),
-    releaseLock: (lock) => connected(() => base.releaseLock(lock)),
-    extendLock: (lock, ttlMs) => connected(() => base.extendLock(lock, ttlMs)),
-    forceReleaseLock: (threadId) => connected(() => base.forceReleaseLock(threadId)),
-    enqueue: (threadId, entry, maxSize) => connected(() => base.enqueue(threadId, entry, maxSize)),
-    dequeue: (threadId) => connected(() => base.dequeue(threadId)),
-    queueDepth: (threadId) => connected(() => base.queueDepth(threadId)),
-    get: (key) => connected(() => base.get(key)),
-    getList: (key) => connected(() => base.getList(key)),
-    set: (key, value, ttlMs) => connected(() => base.set(key, value, ttlMs)),
-    setIfNotExists: (key, value, ttlMs) => connected(() => base.setIfNotExists(key, value, ttlMs)),
-    delete: (key) => connected(() => base.delete(key))
-  };
-}
-function createPrefixedStateAdapter(base, prefix) {
-  const prefixed = (value) => `${prefix}:${value}`;
-  const unprefixed = (value) => value.startsWith(`${prefix}:`) ? value.slice(prefix.length + 1) : value;
-  const prefixLock = (lock) => ({
-    ...lock,
-    threadId: prefixed(lock.threadId)
-  });
-  const unprefixLock = (lock) => ({
-    ...lock,
-    threadId: unprefixed(lock.threadId)
-  });
-  return {
-    appendToList: (key, value, options) => base.appendToList(prefixed(key), value, options),
-    connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
-    subscribe: (threadId) => base.subscribe(prefixed(threadId)),
-    unsubscribe: (threadId) => base.unsubscribe(prefixed(threadId)),
-    isSubscribed: (threadId) => base.isSubscribed(prefixed(threadId)),
-    acquireLock: async (threadId, ttlMs) => {
-      const lock = await base.acquireLock(prefixed(threadId), ttlMs);
-      return lock ? unprefixLock(lock) : null;
-    },
-    releaseLock: (lock) => base.releaseLock(prefixLock(lock)),
-    extendLock: async (lock, ttlMs) => {
-      const prefixedLock = prefixLock(lock);
-      const extended = await base.extendLock(prefixedLock, ttlMs);
-      if (extended) {
-        lock.expiresAt = prefixedLock.expiresAt;
-      }
-      return extended;
-    },
-    forceReleaseLock: (threadId) => base.forceReleaseLock(prefixed(threadId)),
-    enqueue: (threadId, entry, maxSize) => base.enqueue(prefixed(threadId), entry, maxSize),
-    dequeue: (threadId) => base.dequeue(prefixed(threadId)),
-    queueDepth: (threadId) => base.queueDepth(prefixed(threadId)),
-    get: (key) => base.get(prefixed(key)),
-    getList: (key) => base.getList(prefixed(key)),
-    set: (key, value, ttlMs) => base.set(prefixed(key), value, ttlMs),
-    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(prefixed(key), value, ttlMs),
-    delete: (key) => base.delete(prefixed(key))
-  };
-}
-function createQueuedStateAdapter(base, options) {
-  const heartbeats = /* @__PURE__ */ new Map();
-  const shouldHeartbeatLock = (ttlMs) => ttlMs === ACTIVE_LOCK_TTL_MS;
-  const heartbeatKey = (lock) => `${lock.threadId}:${lock.token}`;
-  const stopHeartbeatByKey = (key) => {
-    const heartbeat = heartbeats.get(key);
-    if (!heartbeat) {
-      return;
-    }
-    clearInterval(heartbeat.timer);
-    heartbeats.delete(key);
-  };
-  const stopHeartbeat = (lock) => {
-    stopHeartbeatByKey(heartbeatKey(lock));
-  };
-  const stopHeartbeatsForThread = (threadId) => {
-    for (const [key, heartbeat] of heartbeats) {
-      if (heartbeat.lock.threadId === threadId) {
-        stopHeartbeatByKey(key);
-      }
-    }
-  };
-  const stopAllHeartbeats = () => {
-    for (const key of heartbeats.keys()) {
-      stopHeartbeatByKey(key);
-    }
-  };
-  const runHeartbeat = async (key) => {
-    const heartbeat = heartbeats.get(key);
-    if (!heartbeat || heartbeat.inFlight) {
-      return;
-    }
-    heartbeat.inFlight = true;
-    try {
-      if (Date.now() - heartbeat.startedAtMs >= options.activeLockMaxAgeMs) {
-        stopHeartbeatByKey(key);
-        return;
-      }
-      const extended = await base.extendLock(heartbeat.lock, heartbeat.ttlMs);
-      if (!extended) {
-        stopHeartbeatByKey(key);
-        return;
-      }
-      heartbeat.lock.expiresAt = Date.now() + heartbeat.ttlMs;
-    } catch {
-    } finally {
-      const current = heartbeats.get(key);
-      if (current === heartbeat) {
-        current.inFlight = false;
-      }
-    }
-  };
-  const startOrUpdateHeartbeat = (lock, ttlMs) => {
-    const key = heartbeatKey(lock);
-    const existing = heartbeats.get(key);
-    if (existing) {
-      existing.ttlMs = ttlMs;
-      return;
-    }
-    const timer = setInterval(() => {
-      void runHeartbeat(key);
-    }, ACTIVE_LOCK_HEARTBEAT_MS);
-    timer.unref?.();
-    heartbeats.set(key, {
-      inFlight: false,
-      lock,
-      startedAtMs: Date.now(),
-      timer,
-      ttlMs
-    });
-  };
-  const acquireLock = async (threadId, ttlMs) => {
-    const lock = await base.acquireLock(threadId, ttlMs);
-    if (lock && shouldHeartbeatLock(ttlMs)) {
-      startOrUpdateHeartbeat(lock, ttlMs);
-    }
-    return lock;
-  };
-  return {
-    appendToList: (key, value, options2) => base.appendToList(key, value, options2),
-    connect: () => base.connect(),
-    disconnect: async () => {
-      stopAllHeartbeats();
-      await base.disconnect();
-    },
-    subscribe: (threadId) => base.subscribe(threadId),
-    unsubscribe: (threadId) => base.unsubscribe(threadId),
-    isSubscribed: (threadId) => base.isSubscribed(threadId),
-    acquireLock,
-    releaseLock: async (lock) => {
-      stopHeartbeat(lock);
-      await base.releaseLock(lock);
-    },
-    extendLock: async (lock, ttlMs) => {
-      const extended = await base.extendLock(lock, ttlMs);
-      if (extended) {
-        lock.expiresAt = Date.now() + ttlMs;
-        if (shouldHeartbeatLock(ttlMs)) {
-          startOrUpdateHeartbeat(lock, ttlMs);
-        } else {
-          stopHeartbeat(lock);
-        }
-      } else {
-        stopHeartbeat(lock);
-      }
-      return extended;
-    },
-    forceReleaseLock: async (threadId) => {
-      stopHeartbeatsForThread(threadId);
-      await base.forceReleaseLock(threadId);
-    },
-    enqueue: (threadId, entry, maxSize) => base.enqueue(threadId, entry, maxSize),
-    dequeue: (threadId) => base.dequeue(threadId),
-    queueDepth: (threadId) => base.queueDepth(threadId),
-    get: (key) => base.get(key),
-    getList: (key) => base.getList(key),
-    set: (key, value, ttlMs) => base.set(key, value, ttlMs),
-    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
-    delete: (key) => base.delete(key)
-  };
-}
-function withOptionalPrefix(base, prefix) {
-  return prefix ? createPrefixedStateAdapter(base, prefix) : base;
-}
-function createStateAdapter() {
-  const config = getChatConfig();
-  const activeLockMaxAgeMs = config.bot.turnTimeoutMs + ACTIVE_LOCK_TTL_MS;
-  if (config.state.adapter === "memory") {
-    redisStateAdapter = void 0;
-    return createQueuedStateAdapter(
-      createConnectingStateAdapter(
-        withOptionalPrefix(createMemoryState(), config.state.keyPrefix)
-      ),
-      { activeLockMaxAgeMs }
-    );
-  }
-  if (!config.state.redisUrl) {
-    throw new Error("REDIS_URL is required for durable Slack thread state");
-  }
-  const redisState = createRedisState({
-    url: config.state.redisUrl
-  });
-  redisStateAdapter = redisState;
-  return createQueuedStateAdapter(
-    createConnectingStateAdapter(
-      withOptionalPrefix(redisState, config.state.keyPrefix)
-    ),
-    { activeLockMaxAgeMs }
-  );
-}
-function getOptionalRedisStateAdapter() {
-  getStateAdapter();
-  return redisStateAdapter;
-}
-async function getConnectedStateContext() {
-  const adapter = getStateAdapter();
-  await adapter.connect();
-  return {
-    redisStateAdapter: getOptionalRedisStateAdapter(),
-    stateAdapter: adapter
-  };
-}
-async function getDefaultRedisStateAdapterFor(adapter) {
-  if (adapter !== stateAdapter) {
-    return void 0;
-  }
-  const context = await getConnectedStateContext();
-  return context.stateAdapter === adapter ? context.redisStateAdapter : void 0;
-}
-function getStateAdapter() {
-  if (!stateAdapter) {
-    stateAdapter = createStateAdapter();
-  }
-  return stateAdapter;
-}
-async function disconnectStateAdapter() {
-  if (!stateAdapter) {
-    return;
-  }
-  try {
-    await stateAdapter.disconnect();
-  } finally {
-    stateAdapter = void 0;
-    redisStateAdapter = void 0;
-  }
-}
-
-export {
-  MUTATION_LOCK_TTL_MS,
-  acquireActiveLock,
-  withLock,
-  fenceLock,
-  withActiveLock,
-  getDefaultRedisStateAdapterFor,
-  getStateAdapter,
-  disconnectStateAdapter
-};

package/dist/chunk-PDO5BLNM.js

@@ -1,22 +0,0 @@
-// src/usage-schema.ts
-import { z } from "zod";
-var usageCostSchema = z.object({
-  input: z.number().finite().nonnegative().optional(),
-  output: z.number().finite().nonnegative().optional(),
-  cacheRead: z.number().finite().nonnegative().optional(),
-  cacheWrite: z.number().finite().nonnegative().optional(),
-  total: z.number().finite().nonnegative().optional()
-}).strict();
-var usageSchema = z.object({
-  inputTokens: z.number().int().nonnegative().optional(),
-  outputTokens: z.number().int().nonnegative().optional(),
-  cachedInputTokens: z.number().int().nonnegative().optional(),
-  cacheCreationTokens: z.number().int().nonnegative().optional(),
-  reasoningTokens: z.number().int().nonnegative().optional(),
-  totalTokens: z.number().int().nonnegative().optional(),
-  cost: usageCostSchema.optional()
-}).strict();
-
-export {
-  usageSchema
-};