@sentry/junior 0.106.0 → 0.107.0

package/dist/{chunk-4UYIRWDW.js → chunk-SS67LUOK.js}

@@ -12,7 +12,7 @@ import {
   normalizeGenAiFinishReason,
   serializeGenAiAttribute,
   withSpan
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-O24R4DCK.js";
 
 // src/chat/xml.ts
 function escapeXml(value) {
@@ -75,6 +75,13 @@ var TURN_CONTEXT_TAG = "runtime-turn-context";
 
 // src/chat/pi/transcript.ts
 var RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
+function userMessageContent(message) {
+  const record = message;
+  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
+}
+function isRuntimeTurnContextPart(part) {
+  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(RUNTIME_TURN_CONTEXT_START);
+}
 var EMBEDDED_THREAD_CONTEXT_TAGS = [
   "recent-thread-messages",
   "thread-compactions",
@@ -120,14 +127,14 @@ function extractAssistantText(message) {
   ).map((part) => part.text).join("\n");
 }
 function getTerminalAssistantMessages(messages) {
-  let lastToolResultIndex = -1;
+  let lastNonAssistantIndex = -1;
   for (let index = messages.length - 1; index >= 0; index -= 1) {
-    if (isToolResultMessage(messages[index])) {
-      lastToolResultIndex = index;
+    if (!isAssistantMessage(messages[index])) {
+      lastNonAssistantIndex = index;
       break;
     }
   }
-  return messages.slice(lastToolResultIndex + 1).filter(isAssistantMessage);
+  return messages.slice(lastNonAssistantIndex + 1).filter(isAssistantMessage);
 }
 function trimTrailingAssistantMessages(messages) {
   let end = messages.length;
@@ -136,27 +143,14 @@ function trimTrailingAssistantMessages(messages) {
   }
   return end === messages.length ? [...messages] : messages.slice(0, end);
 }
-function getUserMessageContent(message) {
-  const record = message;
-  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
-}
-function isRuntimeTurnContextPart(part) {
-  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(RUNTIME_TURN_CONTEXT_START);
-}
 function hasRuntimeTurnContext(messages) {
   return messages.some(
-    (message) => getUserMessageContent(message)?.some(
-      (part) => isRuntimeTurnContextPart(part)
-    )
+    (message) => userMessageContent(message)?.some(isRuntimeTurnContextPart)
   );
 }
 function retainRuntimeTurnContext(messages) {
   return messages.flatMap((message) => {
-    const content = getUserMessageContent(message);
-    if (!content) {
-      return [];
-    }
-    const runtimeContent = content.filter(isRuntimeTurnContextPart);
+    const runtimeContent = userMessageContent(message)?.filter(isRuntimeTurnContextPart) ?? [];
     return runtimeContent.length > 0 ? [{ ...message, content: runtimeContent }] : [];
   });
 }
@@ -166,19 +160,13 @@ function instructionTextForProjection(text) {
 }
 function stripRuntimeTurnContext(messages) {
   return messages.flatMap((message) => {
-    const content = getUserMessageContent(message);
-    if (!content) {
-      return [message];
-    }
+    const content = userMessageContent(message);
+    if (!content) return [message];
     const nextContent = content.filter(
       (part) => !isRuntimeTurnContextPart(part)
     );
-    if (nextContent.length === content.length) {
-      return [message];
-    }
-    if (nextContent.length === 0) {
-      return [];
-    }
+    if (nextContent.length === content.length) return [message];
+    if (nextContent.length === 0) return [];
     return [{ ...message, content: nextContent }];
   });
 }
@@ -260,11 +248,10 @@ function nextProviderRetry(args) {
 
 // src/chat/services/context-compaction-marker.ts
 var COMPACTION_SUMMARY_PREFIX = "Context compaction summary for future Junior turns:";
-var LEGACY_COMPACTION_SUMMARY_PREFIX = "Context handoff summary for future Junior turns:";
 var MODEL_HANDOFF_SUMMARY_PREFIX = "Model handoff checkpoint. Continue the outstanding request now using this summary as the complete prior context:";
 function isCompactionSummaryText(text) {
   const normalized = (unwrapCurrentInstruction(text) ?? text).trimStart();
-  return normalized.startsWith(COMPACTION_SUMMARY_PREFIX) || normalized.startsWith(LEGACY_COMPACTION_SUMMARY_PREFIX) || normalized.startsWith(MODEL_HANDOFF_SUMMARY_PREFIX);
+  return normalized.startsWith(COMPACTION_SUMMARY_PREFIX) || normalized.startsWith(MODEL_HANDOFF_SUMMARY_PREFIX);
 }
 function hasCompactedConversationContext(messages) {
   return messages.some((message) => {
@@ -583,14 +570,17 @@ var ModelProfileNotConfiguredError = class extends Error {
   }
 };
 function modelIdForProfile(config, profile) {
-  if (profile === STANDARD_MODEL_PROFILE) {
-    return config.modelId;
-  }
-  const modelId = Object.hasOwn(config.modelProfiles, profile) ? config.modelProfiles[profile] : void 0;
-  if (!modelId) {
+  return profileConfig(config, profile).modelId;
+}
+function standardModelId(config) {
+  return modelIdForProfile(config, STANDARD_MODEL_PROFILE);
+}
+function profileConfig(config, profile) {
+  const profileConfig2 = Object.hasOwn(config.profiles, profile) ? config.profiles[profile] : void 0;
+  if (!profileConfig2) {
     throw new ModelProfileNotConfiguredError(profile);
   }
-  return modelId;
+  return profileConfig2;
 }
 
 // src/chat/config.ts
@@ -679,10 +669,10 @@ function parseSlashCommand(rawValue) {
   }
   return command;
 }
-var DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "openai/gpt-5.5").id;
+var DEFAULT_MODEL_ID = getModel("vercel-ai-gateway", "xai/grok-4.5").id;
 var DEFAULT_FAST_MODEL_ID = getModel(
   "vercel-ai-gateway",
-  "openai/gpt-5.4-mini"
+  "anthropic/claude-haiku-4.5"
 ).id;
 var DEFAULT_HANDOFF_MODEL_ID = getModel(
   "vercel-ai-gateway",
@@ -698,9 +688,13 @@ function validateGatewayModelId(raw) {
 function validateEmbeddingModelId(raw) {
   return toOptionalTrimmed(raw);
 }
-function parseModelProfiles(rawValue, handoffModelId) {
+function parseProfiles(rawValue, standardModelId2, handoffModelId) {
   const profiles = {
-    [DEFAULT_HANDOFF_MODEL_PROFILE]: handoffModelId
+    [STANDARD_MODEL_PROFILE]: { modelId: standardModelId2 },
+    [DEFAULT_HANDOFF_MODEL_PROFILE]: {
+      modelId: handoffModelId,
+      reasoningLevel: "high"
+    }
   };
   const trimmed = toOptionalTrimmed(rawValue);
   if (trimmed === void 0) {
@@ -731,7 +725,7 @@ function parseModelProfiles(rawValue, handoffModelId) {
     if (!modelId) {
       throw new Error(`AI_MODEL_PROFILES.${profile} must not be empty`);
     }
-    profiles[profile] = modelId;
+    profiles[profile] = { modelId };
   }
   return profiles;
 }
@@ -757,8 +751,7 @@ function readBotConfig(env) {
   const handoffModelId = validateGatewayModelId(env.AI_HANDOFF_MODEL) ?? DEFAULT_HANDOFF_MODEL_ID;
   return {
     userName: toOptionalTrimmed(env.JUNIOR_BOT_NAME) ?? "junior",
-    modelId,
-    modelProfiles: parseModelProfiles(env.AI_MODEL_PROFILES, handoffModelId),
+    profiles: parseProfiles(env.AI_MODEL_PROFILES, modelId, handoffModelId),
     modelContextWindowTokens: parseOptionalPositiveInteger(
       "AI_MODEL_CONTEXT_WINDOW_TOKENS",
       env.AI_MODEL_CONTEXT_WINDOW_TOKENS
@@ -873,245 +866,6 @@ function setSlackReactionConfig(overrides) {
   }
 }
 
-// src/chat/state/adapter.ts
-import { createMemoryState } from "@chat-adapter/state-memory";
-import { createRedisState } from "@chat-adapter/state-redis";
-
-// src/chat/state/locks.ts
-var ACTIVE_LOCK_TTL_MS = 9e4;
-async function acquireActiveLock(state, threadId) {
-  return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
-}
-
-// src/chat/state/adapter.ts
-var ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
-var stateAdapter;
-var redisStateAdapter;
-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(
-      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(
-    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 {
   toOptionalTrimmed,
   escapeXml,
@@ -1154,6 +908,8 @@ export {
   modelProfileSchema,
   ModelProfileNotConfiguredError,
   modelIdForProfile,
+  standardModelId,
+  profileConfig,
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig,
   botConfig,
@@ -1163,10 +919,5 @@ export {
   getSlackClientSecret,
   getRuntimeMetadata,
   getSlackReactionConfig,
-  setSlackReactionConfig,
-  acquireActiveLock,
-  getConnectedStateContext,
-  getDefaultRedisStateAdapterFor,
-  getStateAdapter,
-  disconnectStateAdapter
+  setSlackReactionConfig
 };

package/dist/{chunk-FXFQNHRU.js → chunk-VFUK3X5B.js}

@@ -1,10 +1,12 @@
+// src/db/schema/destinations.ts
+import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+import { z } from "zod";
+
 // src/db/schema/timestamps.ts
 import { timestamp } from "drizzle-orm/pg-core";
 var timestamptz = (name) => timestamp(name, { withTimezone: true });
 
 // src/db/schema/destinations.ts
-import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
-import { z } from "zod";
 var juniorDestinationKindSchema = z.enum([
   "channel",
   "dm",

package/dist/{chunk-3MPPVPGZ.js → chunk-VH6KWKG2.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-4ZNGQH7C.js";
 import {
   getSlackBotToken
-} from "./chunk-4UYIRWDW.js";
+} from "./chunk-SS67LUOK.js";
 import {
   logWarn,
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-O24R4DCK.js";
 import {
   parseSlackChannelReferenceId
 } from "./chunk-7FBGKXPE.js";

package/dist/chunk-VIXFG2VC.js

@@ -0,0 +1,182 @@
+import {
+  parseSlackTeamId
+} from "./chunk-7FBGKXPE.js";
+
+// src/chat/actor.ts
+import { z } 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 = z.string().min(1).refine((value) => value === value.trim());
+var storedSlackActorSchema = z.object({
+  email: exactStoredStringSchema.optional(),
+  fullName: exactStoredStringSchema.optional(),
+  platform: z.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) } : {},
+    ...canUseInputProfile && cleanActorDisplayName(input?.fullName, actorUserId) ? {
+      fullName: cleanActorDisplayName(input?.fullName, actorUserId)
+    } : {},
+    platform,
+    userId: actorUserId,
+    ...canUseInputProfile && cleanActorDisplayName(input?.userName, actorUserId) ? {
+      userName: cleanActorDisplayName(input?.userName, actorUserId)
+    } : {}
+  };
+  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 } : {},
+    ...actor.fullName ? { fullName: actor.fullName } : {},
+    platform: actor.platform,
+    slackUserId: actor.userId,
+    ...actor.userName ? { slackUserName: actor.userName } : {},
+    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 {
+  storedSlackActorSchema,
+  isUserActor,
+  parseActorUserId,
+  isActorUserId,
+  createActor,
+  createSlackActor,
+  parseStoredSlackActor,
+  toStoredSlackActor,
+  createSlackResumeActor
+};