@sentry/junior 0.57.0 → 0.58.0

package/dist/{chunk-AA5TIFN5.js → chunk-FKEKRBUB.js}

@@ -1,13 +1,211 @@
 import {
   extractGenAiUsageAttributes,
-  getPluginRuntimeDependencies,
-  getPluginRuntimePostinstall,
   logException,
   logWarn,
   serializeGenAiAttribute,
   setSpanAttributes,
+  toOptionalString,
   withSpan
-} from "./chunk-TTUY467K.js";
+} from "./chunk-H652GMDH.js";
+
+// src/chat/slack/context.ts
+function toTrimmedSlackString(value) {
+  const normalized = toOptionalString(value);
+  return normalized?.trim() || void 0;
+}
+function parseSlackThreadId(threadId) {
+  const normalizedThreadId = toTrimmedSlackString(threadId);
+  if (!normalizedThreadId) {
+    return void 0;
+  }
+  const parts = normalizedThreadId.split(":");
+  if (parts.length !== 3 || parts[0] !== "slack") {
+    return void 0;
+  }
+  const channelId = toTrimmedSlackString(parts[1]);
+  const threadTs = toTrimmedSlackString(parts[2]);
+  if (!channelId || !threadTs) {
+    return void 0;
+  }
+  return { channelId, threadTs };
+}
+function resolveSlackChannelIdFromThreadId(threadId) {
+  return parseSlackThreadId(threadId)?.channelId;
+}
+function resolveSlackChannelIdFromMessage(message) {
+  const messageChannelId = toTrimmedSlackString(
+    message.channelId
+  );
+  if (messageChannelId) {
+    return messageChannelId;
+  }
+  const raw = message.raw;
+  if (raw && typeof raw === "object") {
+    const rawChannel = toTrimmedSlackString(
+      raw.channel
+    );
+    if (rawChannel) {
+      return rawChannel;
+    }
+  }
+  const threadId = toTrimmedSlackString(
+    message.threadId
+  );
+  return resolveSlackChannelIdFromThreadId(threadId);
+}
+
+// src/chat/conversation-privacy.ts
+var SAFE_METADATA_KEY_LIMIT = 20;
+function conversationPrivacyFromChannelId(channelId) {
+  const normalized = channelId?.trim();
+  if (!normalized) return void 0;
+  return normalized.startsWith("C") ? "public" : "private";
+}
+function conversationPrivacyFromConversationId(conversationId) {
+  if (!conversationId?.trim()) return void 0;
+  const slackThread = parseSlackThreadId(conversationId);
+  if (slackThread) {
+    return conversationPrivacyFromChannelId(slackThread.channelId);
+  }
+  return "private";
+}
+function resolveConversationPrivacy(input) {
+  return conversationPrivacyFromChannelId(input.channelId) ?? conversationPrivacyFromConversationId(input.conversationId);
+}
+function canExposeConversationPayload(input) {
+  return resolveConversationPrivacy(input) === "public";
+}
+function contentMetadata(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", chars: content.length }];
+  }
+  if (!Array.isArray(content)) {
+    return { type: typeof content };
+  }
+  return content.map((part) => {
+    if (!part || typeof part !== "object") {
+      return { type: typeof part };
+    }
+    const record = part;
+    const type = typeof record.type === "string" ? record.type : "unknown";
+    return {
+      type,
+      ...typeof record.text === "string" ? { chars: record.text.length } : {},
+      ...typeof record.mimeType === "string" ? { mimeType: record.mimeType } : {},
+      ...typeof record.mediaType === "string" ? { mediaType: record.mediaType } : {},
+      ...typeof record.data === "string" ? { dataChars: record.data.length } : {}
+    };
+  });
+}
+function toGenAiMessageMetadata(message) {
+  const record = message && typeof message === "object" ? message : {};
+  return {
+    role: record.role,
+    content: contentMetadata(record.content)
+  };
+}
+function toGenAiTextMetadata(text) {
+  return { type: "text", chars: text.length };
+}
+function payloadType(payload) {
+  return Array.isArray(payload) ? "array" : typeof payload;
+}
+function payloadKeys(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return void 0;
+  }
+  const keys = Object.keys(payload).slice(
+    0,
+    SAFE_METADATA_KEY_LIMIT
+  );
+  return keys.length > 0 ? keys : void 0;
+}
+function serializedLength(payload) {
+  const serialized = typeof payload === "string" ? payload : JSON.stringify(payload);
+  return serialized?.length ?? 0;
+}
+function toGenAiPayloadMetadata(payload) {
+  const base = {
+    type: payloadType(payload),
+    chars: serializedLength(payload)
+  };
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return base;
+  }
+  const keys = payloadKeys(payload);
+  return {
+    ...base,
+    ...keys ? { keys } : {}
+  };
+}
+function toGenAiPayloadTraceAttributes(prefix, payload) {
+  const attributes = {
+    [`${prefix}.type`]: payloadType(payload),
+    [`${prefix}.size_chars`]: serializedLength(payload)
+  };
+  const keys = payloadKeys(payload);
+  if (keys) {
+    attributes[`${prefix}.keys`] = keys;
+  }
+  return attributes;
+}
+function summarizeContent(content) {
+  if (typeof content === "string") {
+    return { chars: content.length, partTypes: ["text"] };
+  }
+  if (!Array.isArray(content)) {
+    return {
+      chars: serializedLength(content),
+      partTypes: [payloadType(content)]
+    };
+  }
+  let chars = 0;
+  const partTypes = /* @__PURE__ */ new Set();
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      chars += serializedLength(part);
+      partTypes.add(payloadType(part));
+      continue;
+    }
+    const record = part;
+    const type = typeof record.type === "string" ? record.type : "unknown";
+    partTypes.add(type);
+    if (typeof record.text === "string") {
+      chars += record.text.length;
+    } else if (typeof record.data === "string") {
+      chars += record.data.length;
+    } else {
+      chars += serializedLength(part);
+    }
+  }
+  return { chars, partTypes: [...partTypes] };
+}
+function toGenAiMessagesTraceAttributes(prefix, messages) {
+  let contentChars = 0;
+  const roles = /* @__PURE__ */ new Set();
+  const partTypes = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (!message || typeof message !== "object") {
+      contentChars += serializedLength(message);
+      continue;
+    }
+    const record = message;
+    if (typeof record.role === "string") {
+      roles.add(record.role);
+    }
+    const summary = summarizeContent(record.content);
+    contentChars += summary.chars;
+    for (const partType of summary.partTypes) {
+      partTypes.add(partType);
+    }
+  }
+  return {
+    [`${prefix}.message_count`]: messages.length,
+    [`${prefix}.content_chars`]: contentChars,
+    ...roles.size > 0 ? { [`${prefix}.roles`]: [...roles] } : {},
+    ...partTypes.size > 0 ? { [`${prefix}.part_types`]: [...partTypes] } : {}
+  };
+}
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";
@@ -43,6 +241,8 @@ registerApiProvider({
 });
 var GATEWAY_PROVIDER = "vercel-ai-gateway";
 var GEN_AI_PROVIDER_NAME = GATEWAY_PROVIDER;
+var GEN_AI_SERVER_ADDRESS = "ai-gateway.vercel.sh";
+var GEN_AI_SERVER_PORT = 443;
 var GEN_AI_OPERATION_CHAT = "chat";
 var MISSING_GATEWAY_CREDENTIALS_ERROR = "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)";
 function getGatewayApiKey() {
@@ -54,35 +254,6 @@ function getPiGatewayApiKeyOverride() {
 function extractText(message) {
   return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join("").trim();
 }
-function contentMetadata(content) {
-  if (typeof content === "string") {
-    return [{ type: "text", chars: content.length }];
-  }
-  if (!Array.isArray(content)) {
-    return { type: typeof content };
-  }
-  return content.map((part) => {
-    if (!part || typeof part !== "object") {
-      return { type: typeof part };
-    }
-    const record = part;
-    const type = typeof record.type === "string" ? record.type : "unknown";
-    return {
-      type,
-      ...typeof record.text === "string" ? { chars: record.text.length } : {},
-      ...typeof record.mimeType === "string" ? { mimeType: record.mimeType } : {},
-      ...typeof record.mediaType === "string" ? { mediaType: record.mediaType } : {},
-      ...typeof record.data === "string" ? { dataChars: record.data.length } : {}
-    };
-  });
-}
-function toMessageMetadata(message) {
-  const record = message;
-  return {
-    role: record.role,
-    content: contentMetadata(record.content)
-  };
-}
 function parseJsonCandidate(text) {
   const trimmed = text.trim();
   if (!trimmed) return void 0;
@@ -155,29 +326,40 @@ function resolveGatewayModel(modelId) {
 async function completeText(params) {
   const model = resolveGatewayModel(params.modelId);
   const apiKey = getPiGatewayApiKeyOverride();
-  const messageAttributeMode = params.messageAttributeMode ?? "content";
+  const privacy = resolveConversationPrivacy({
+    channelId: typeof params.metadata?.channelId === "string" ? params.metadata.channelId : void 0,
+    conversationId: typeof params.metadata?.conversationId === "string" ? params.metadata.conversationId : typeof params.metadata?.threadId === "string" ? params.metadata.threadId : void 0
+  });
+  const effectivePrivacy = privacy ?? "private";
+  const messageAttributeMode = params.messageAttributeMode ?? (effectivePrivacy === "public" ? "content" : "metadata");
   const requestMessagesAttribute = serializeGenAiAttribute(
-    messageAttributeMode === "metadata" ? params.messages.map(toMessageMetadata) : params.messages
+    messageAttributeMode === "metadata" ? params.messages.map(toGenAiMessageMetadata) : params.messages
   );
   const systemInstructionsAttribute = params.system ? serializeGenAiAttribute(
-    messageAttributeMode === "metadata" ? [{ type: "text", chars: params.system.length }] : [{ type: "text", content: params.system }]
+    messageAttributeMode === "metadata" ? [toGenAiTextMetadata(params.system)] : [{ type: "text", content: params.system }]
   ) : void 0;
   const baseAttributes = {
     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
     "gen_ai.operation.name": GEN_AI_OPERATION_CHAT,
     "gen_ai.request.model": params.modelId,
+    "gen_ai.output.type": "text",
+    "server.address": GEN_AI_SERVER_ADDRESS,
+    "server.port": GEN_AI_SERVER_PORT,
+    "app.conversation.privacy": effectivePrivacy,
     ...params.thinkingLevel ? { "app.ai.reasoning_effort": params.thinkingLevel } : {}
   };
   const startAttributes = {
     ...baseAttributes,
+    ...toGenAiMessagesTraceAttributes("app.ai.input", params.messages),
+    ...params.system ? { "app.ai.system_instructions.content_chars": params.system.length } : {},
     ...systemInstructionsAttribute ? { "gen_ai.system_instructions": systemInstructionsAttribute } : {},
     ...requestMessagesAttribute ? { "gen_ai.input.messages": requestMessagesAttribute } : {},
     "app.ai.auth_mode": apiKey ? "oidc" : "api_key"
   };
   return withSpan(
-    "ai.chat_completion",
+    `${GEN_AI_OPERATION_CHAT} ${params.modelId}`,
     "gen_ai.chat",
-    { modelId: params.modelId },
+    logContextFromMetadata(params.modelId, params.metadata),
     async () => {
       const message = await completeSimple(
         model,
@@ -199,7 +381,7 @@ async function completeText(params) {
         messageAttributeMode === "metadata" ? [
           {
             role: "assistant",
-            content: outputText ? [{ type: "text", chars: outputText.length }] : []
+            content: outputText ? [toGenAiTextMetadata(outputText)] : []
           }
         ] : [
           {
@@ -211,6 +393,12 @@ async function completeText(params) {
       const usageAttributes = extractGenAiUsageAttributes(message);
       const endAttributes = {
         ...baseAttributes,
+        ...toGenAiMessagesTraceAttributes("app.ai.output", [
+          {
+            role: "assistant",
+            content: outputText ? [{ type: "text", text: outputText }] : []
+          }
+        ]),
         ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
         ...usageAttributes,
         ...message.stopReason ? { "gen_ai.response.finish_reasons": [message.stopReason] } : {}
@@ -237,6 +425,19 @@ async function completeText(params) {
     startAttributes
   );
 }
+function logContextFromMetadata(modelId, metadata) {
+  const conversationId = typeof metadata?.conversationId === "string" ? metadata.conversationId : typeof metadata?.threadId === "string" ? metadata.threadId : void 0;
+  const slackThreadId = typeof metadata?.threadId === "string" ? metadata.threadId : void 0;
+  const slackChannelId = typeof metadata?.channelId === "string" ? metadata.channelId : void 0;
+  const runId = typeof metadata?.runId === "string" ? metadata.runId : void 0;
+  return {
+    modelId,
+    ...conversationId ? { conversationId } : {},
+    ...slackThreadId ? { slackThreadId } : {},
+    ...slackChannelId ? { slackChannelId } : {},
+    ...runId ? { runId } : {}
+  };
+}
 async function completeObject(params) {
   let text = "";
   try {
@@ -665,6 +866,18 @@ function createStateAdapter() {
     { activeLockMaxAgeMs }
   );
 }
+function getOptionalRedisStateAdapter() {
+  getStateAdapter();
+  return redisStateAdapter;
+}
+async function getConnectedStateContext() {
+  const adapter = getStateAdapter();
+  await adapter.connect();
+  return {
+    redisStateAdapter: getOptionalRedisStateAdapter(),
+    stateAdapter: adapter
+  };
+}
 function getStateAdapter() {
   if (!stateAdapter) {
     stateAdapter = createStateAdapter();
@@ -683,698 +896,28 @@ async function disconnectStateAdapter() {
   }
 }
 
-// src/chat/sandbox/runtime-dependency-snapshots.ts
-import { createHash } from "crypto";
-import { Sandbox } from "@vercel/sandbox";
-
-// src/chat/sandbox/noninteractive-command.ts
-var NON_INTERACTIVE_ENV = {
-  CI: "1",
-  TERM: "dumb",
-  NO_COLOR: "1",
-  PAGER: "cat",
-  GIT_PAGER: "cat",
-  GH_PROMPT_DISABLED: "1",
-  GH_NO_UPDATE_NOTIFIER: "1",
-  GH_NO_EXTENSION_UPDATE_NOTIFIER: "1",
-  GH_SPINNER_DISABLED: "1",
-  GIT_TERMINAL_PROMPT: "0",
-  GCM_INTERACTIVE: "never",
-  DEBIAN_FRONTEND: "noninteractive",
-  // Git credential isolation: prevent git from sending its own auth so the
-  // sandbox egress proxy's header transforms are the sole credential source.
-  GIT_ASKPASS: "/bin/true",
-  GIT_CONFIG_NOSYSTEM: "1",
-  GIT_CONFIG_COUNT: "2",
-  GIT_CONFIG_KEY_0: "credential.helper",
-  GIT_CONFIG_VALUE_0: "",
-  GIT_CONFIG_KEY_1: "http.emptyAuth",
-  GIT_CONFIG_VALUE_1: "true"
-};
-function shellQuote(value) {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function buildEnvExports(options) {
-  const lines = [];
-  if (options.pathPrefix) {
-    lines.push(`export PATH="${options.pathPrefix}"`);
-  }
-  for (const [key, value] of Object.entries(NON_INTERACTIVE_ENV)) {
-    lines.push(`export ${key}=${shellQuote(value)}`);
-  }
-  for (const [key, value] of Object.entries(options.env ?? {})) {
-    lines.push(`export ${key}=${shellQuote(value)}`);
-  }
-  return lines;
-}
-function toCommandScript(input) {
-  return [shellQuote(input.cmd), ...(input.args ?? []).map(shellQuote)].join(
-    " "
-  );
-}
-function buildNonInteractiveShellScript(script, options = {}) {
-  return [...buildEnvExports(options), "exec </dev/null", script].join(" && ");
-}
-function buildNonInteractiveCommand(input) {
-  return {
-    cmd: "bash",
-    args: [
-      input.login ? "-lc" : "-c",
-      buildNonInteractiveShellScript(toCommandScript(input), {
-        env: input.env,
-        pathPrefix: input.pathPrefix
-      })
-    ]
-  };
-}
-async function runNonInteractiveCommand(sandbox, input) {
-  const command = {
-    ...buildNonInteractiveCommand(input),
-    ...input.cwd ? { cwd: input.cwd } : {},
-    ...input.sudo !== void 0 ? { sudo: input.sudo } : {}
-  };
-  return await sandbox.runCommand(command);
-}
-
-// src/chat/sandbox/credentials.ts
-function getVercelSandboxCredentials() {
-  const token = toOptionalTrimmed(process.env.VERCEL_TOKEN);
-  const teamId = toOptionalTrimmed(process.env.VERCEL_TEAM_ID);
-  const projectId = toOptionalTrimmed(process.env.VERCEL_PROJECT_ID);
-  if (token && teamId && projectId) {
-    return { token, teamId, projectId };
-  }
-  return void 0;
-}
-
-// src/chat/sandbox/workspace.ts
-function createSandboxInstance(sandbox) {
-  return {
-    sandboxId: sandbox.name,
-    get sandboxEgressId() {
-      return sandbox.currentSession().sessionId;
-    },
-    fs: sandbox.fs,
-    extendTimeout(duration) {
-      return sandbox.extendTimeout(duration);
-    },
-    mkDir(path) {
-      return sandbox.mkDir(path);
-    },
-    readFileToBuffer(input) {
-      return sandbox.readFileToBuffer(input);
-    },
-    runCommand(input) {
-      return sandbox.runCommand(input);
-    },
-    async snapshot() {
-      const snapshot = await sandbox.snapshot();
-      return { snapshotId: snapshot.snapshotId };
-    },
-    stop() {
-      return sandbox.stop();
-    },
-    update(params) {
-      return sandbox.update(params);
-    },
-    writeFiles(files) {
-      return sandbox.writeFiles(files);
-    }
-  };
-}
-
-// src/chat/sandbox/paths.ts
-function normalizeWorkspaceRoot(input) {
-  const candidate = (input ?? "").trim();
-  if (!candidate) {
-    return "/vercel/sandbox";
-  }
-  const normalized = candidate.replace(/\/+$/, "");
-  return normalized.startsWith("/") ? normalized : `/${normalized}`;
-}
-var SANDBOX_WORKSPACE_ROOT = normalizeWorkspaceRoot(
-  process.env.VERCEL_SANDBOX_WORKSPACE_DIR
-);
-var SANDBOX_SKILLS_ROOT = `${SANDBOX_WORKSPACE_ROOT}/skills`;
-var SANDBOX_DATA_ROOT = `${SANDBOX_WORKSPACE_ROOT}/data`;
-function sandboxSkillDir(skillName) {
-  return `${SANDBOX_SKILLS_ROOT}/${skillName}`;
-}
-function sandboxSkillFile(skillName) {
-  return `${sandboxSkillDir(skillName)}/SKILL.md`;
-}
-
-// src/chat/sandbox/runtime-dependency-snapshots.ts
-var SNAPSHOT_CACHE_PREFIX = "junior:sandbox_snapshot_profile";
-var SNAPSHOT_LOCK_PREFIX = "junior:sandbox_snapshot_lock";
-var SNAPSHOT_PROFILE_VERSION = 1;
-var SNAPSHOT_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var SNAPSHOT_BUILD_LOCK_TTL_MS = 10 * 60 * 1e3;
-var SNAPSHOT_WAIT_FOR_LOCK_MS = SNAPSHOT_BUILD_LOCK_TTL_MS + 30 * 1e3;
-var DEFAULT_FLOATING_DEP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function profileCacheKey(profileHash) {
-  return `${SNAPSHOT_CACHE_PREFIX}:${profileHash}`;
-}
-function profileLockKey(profileHash) {
-  return `${SNAPSHOT_LOCK_PREFIX}:${profileHash}`;
-}
-function isExactNpmVersion(version) {
-  return /^\d+\.\d+\.\d+(?:[-+][a-z0-9.]+)?$/i.test(version.trim());
-}
-function hasFloatingSelector(dep) {
-  return dep.type === "npm" && !isExactNpmVersion(dep.version);
-}
-function parseFloatingDepMaxAgeMs() {
-  const raw = process.env.SANDBOX_SNAPSHOT_FLOATING_MAX_AGE_MS;
-  if (!raw?.trim()) {
-    return DEFAULT_FLOATING_DEP_MAX_AGE_MS;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    return DEFAULT_FLOATING_DEP_MAX_AGE_MS;
-  }
-  return parsed;
-}
-function buildDependencyProfile(runtime) {
-  const dependencies = getPluginRuntimeDependencies();
-  const postinstall = getPluginRuntimePostinstall();
-  if (dependencies.length === 0 && postinstall.length === 0) {
-    return null;
-  }
-  const rebuildEpoch = process.env.SANDBOX_SNAPSHOT_REBUILD_EPOCH?.trim() ?? "";
-  const hasFloatingVersions = dependencies.some((dep) => hasFloatingSelector(dep)) || postinstall.length > 0;
-  const hashInput = JSON.stringify({
-    version: SNAPSHOT_PROFILE_VERSION,
-    runtime,
-    rebuildEpoch,
-    dependencies,
-    postinstall
-  });
-  const profileHash = createHash("sha256").update(hashInput).digest("hex");
-  return {
-    profileHash,
-    dependencyCount: dependencies.length,
-    hasFloatingVersions,
-    dependencies,
-    postinstall
-  };
-}
-function getRuntimeDependencyProfileHash(runtime) {
-  return buildDependencyProfile(runtime)?.profileHash;
-}
-function shouldRebuildCachedSnapshot(profile, cached) {
-  if (!profile.hasFloatingVersions) {
-    return false;
-  }
-  const maxAgeMs = parseFloatingDepMaxAgeMs();
-  if (maxAgeMs === 0) {
-    return true;
-  }
-  return Date.now() - cached.createdAtMs > maxAgeMs;
-}
-async function getCachedSnapshot(profileHash) {
-  try {
-    const state = getStateAdapter();
-    await state.connect();
-    const raw = await state.get(profileCacheKey(profileHash));
-    if (typeof raw !== "string") {
-      return null;
-    }
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || typeof parsed.profileHash !== "string" || typeof parsed.snapshotId !== "string" || typeof parsed.runtime !== "string" || typeof parsed.createdAtMs !== "number" || typeof parsed.dependencyCount !== "number") {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function setCachedSnapshot(entry) {
-  const state = getStateAdapter();
-  await state.connect();
-  await state.set(
-    profileCacheKey(entry.profileHash),
-    JSON.stringify(entry),
-    SNAPSHOT_CACHE_TTL_MS
-  );
-}
-async function withSnapshotSpan(name, op, attributes, callback) {
-  return await withSpan(name, op, {}, callback, attributes);
-}
-async function runOrThrow(sandbox, params, label) {
-  const result = await runNonInteractiveCommand(sandbox, params);
-  if (result.exitCode === 0) {
-    return;
-  }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
-  const detail = stderr || stdout || "command failed";
-  throw new Error(`${label} failed: ${detail}`);
-}
-async function tryRun(sandbox, params) {
-  const result = await runNonInteractiveCommand(sandbox, params);
-  if (result.exitCode === 0) {
-    return { ok: true };
-  }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
-  return { ok: false, detail: stderr || stdout || "command failed" };
-}
-async function installGhCliViaDnf(sandbox) {
-  const direct = await tryRun(sandbox, {
-    cmd: "dnf",
-    args: ["install", "-y", "gh"],
-    sudo: true
-  });
-  if (direct.ok) {
-    return;
-  }
-  const dnf5Repo = await tryRun(sandbox, {
-    cmd: "dnf",
-    args: [
-      "config-manager",
-      "addrepo",
-      "--from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo"
-    ],
-    sudo: true
-  });
-  if (!dnf5Repo.ok) {
-    await runOrThrow(
-      sandbox,
-      {
-        cmd: "dnf",
-        args: ["install", "-y", "dnf-command(config-manager)"],
-        sudo: true
-      },
-      "dnf install dnf-command(config-manager)"
-    );
-    await runOrThrow(
-      sandbox,
-      {
-        cmd: "dnf",
-        args: [
-          "config-manager",
-          "--add-repo",
-          "https://cli.github.com/packages/rpm/gh-cli.repo"
-        ],
-        sudo: true
-      },
-      "dnf config-manager --add-repo gh-cli.repo"
-    );
-  }
-  await runOrThrow(
-    sandbox,
-    {
-      cmd: "dnf",
-      args: ["install", "-y", "gh", "--repo", "gh-cli"],
-      sudo: true
-    },
-    "dnf install gh --repo gh-cli"
-  );
-}
-function runtimeDependencyFilePath(url, sha256) {
-  let urlBasename = "package.rpm";
-  try {
-    const pathname = new URL(url).pathname;
-    const segments = pathname.split("/").filter(Boolean);
-    const candidate = segments[segments.length - 1];
-    if (candidate) {
-      urlBasename = candidate;
-    }
-  } catch {
-  }
-  const sanitizedBasename = urlBasename.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return `/tmp/junior-runtime-${sha256.slice(0, 12)}-${sanitizedBasename}`;
-}
-async function installRuntimeDependencies(sandbox, deps) {
-  const systemDeps = deps.filter(
-    (dep) => dep.type === "system"
-  );
-  const npmPackages = deps.filter(
-    (dep) => dep.type === "npm"
-  ).map((dep) => `${dep.package}@${dep.version}`);
-  if (systemDeps.length > 0) {
-    await withSnapshotSpan(
-      "sandbox.snapshot.install_system",
-      "sandbox.snapshot.install.system",
-      {
-        "app.sandbox.snapshot.install.system_count": systemDeps.length
-      },
-      async () => {
-        for (const dep of systemDeps) {
-          if ("url" in dep) {
-            const rpmPath = runtimeDependencyFilePath(dep.url, dep.sha256);
-            await runOrThrow(
-              sandbox,
-              {
-                cmd: "curl",
-                args: ["-fsSL", dep.url, "-o", rpmPath]
-              },
-              `curl download ${dep.url}`
-            );
-            const checksumResult = await runNonInteractiveCommand(sandbox, {
-              cmd: "sha256sum",
-              args: [rpmPath]
-            });
-            const checksumStdout = (await checksumResult.stdout()).trim();
-            const checksumStderr = (await checksumResult.stderr()).trim();
-            if (checksumResult.exitCode !== 0) {
-              throw new Error(
-                `sha256sum failed: ${checksumStderr || checksumStdout || "command failed"}`
-              );
-            }
-            const actualChecksum = checksumStdout.split(/\s+/)[0]?.toLowerCase();
-            if (!actualChecksum) {
-              throw new Error("sha256sum produced empty output");
-            }
-            if (actualChecksum !== dep.sha256) {
-              throw new Error(
-                `checksum mismatch for ${dep.url}: expected ${dep.sha256}, got ${actualChecksum}`
-              );
-            }
-            await runOrThrow(
-              sandbox,
-              {
-                cmd: "dnf",
-                args: ["install", "-y", rpmPath],
-                sudo: true
-              },
-              `dnf install ${dep.url}`
-            );
-            continue;
-          }
-          if (dep.package === "gh") {
-            await installGhCliViaDnf(sandbox);
-            continue;
-          }
-          await runOrThrow(
-            sandbox,
-            {
-              cmd: "dnf",
-              args: ["install", "-y", dep.package],
-              sudo: true
-            },
-            `dnf install ${dep.package}`
-          );
-        }
-      }
-    );
-  }
-  if (npmPackages.length > 0) {
-    await withSnapshotSpan(
-      "sandbox.snapshot.install_npm",
-      "sandbox.snapshot.install.npm",
-      {
-        "app.sandbox.snapshot.install.npm_count": npmPackages.length
-      },
-      async () => {
-        await runOrThrow(
-          sandbox,
-          {
-            cmd: "npm",
-            args: [
-              "install",
-              "--global",
-              "--prefix",
-              `${SANDBOX_WORKSPACE_ROOT}/.junior`,
-              ...npmPackages
-            ]
-          },
-          "npm install"
-        );
-      }
-    );
-  }
-}
-async function runRuntimePostinstall(sandbox, commands) {
-  if (commands.length === 0) {
-    return;
-  }
-  await withSnapshotSpan(
-    "sandbox.snapshot.runtime_postinstall",
-    "sandbox.snapshot.runtime_postinstall",
-    {
-      "app.sandbox.snapshot.runtime_postinstall.count": commands.length
-    },
-    async () => {
-      for (const command of commands) {
-        const result = await runNonInteractiveCommand(sandbox, {
-          cmd: command.cmd,
-          args: command.args,
-          login: true,
-          pathPrefix: `${SANDBOX_WORKSPACE_ROOT}/.junior/bin:$PATH`,
-          ...command.sudo !== void 0 ? { sudo: command.sudo } : {}
-        });
-        if (result.exitCode === 0) {
-          continue;
-        }
-        const stderr = (await result.stderr()).trim();
-        const stdout = (await result.stdout()).trim();
-        const detail = stderr || stdout || "command failed";
-        throw new Error(`runtime-postinstall ${command.cmd} failed: ${detail}`);
-      }
-    }
-  );
-}
-async function createDependencySnapshot(profile, runtime, timeoutMs) {
-  return await withSnapshotSpan(
-    "sandbox.snapshot.build",
-    "sandbox.snapshot.build",
-    {
-      "app.sandbox.runtime": runtime,
-      "app.sandbox.snapshot.dependency_count": profile.dependencyCount
-    },
-    async () => {
-      const sandboxCredentials = getVercelSandboxCredentials();
-      const sandbox = createSandboxInstance(
-        await Sandbox.create({
-          timeout: timeoutMs,
-          runtime,
-          ...sandboxCredentials ?? {}
-        })
-      );
-      try {
-        await installRuntimeDependencies(sandbox, profile.dependencies);
-        await runRuntimePostinstall(sandbox, profile.postinstall);
-        return await withSnapshotSpan(
-          "sandbox.snapshot.capture",
-          "sandbox.snapshot.capture",
-          {
-            "app.sandbox.snapshot.dependency_count": profile.dependencyCount
-          },
-          async () => {
-            const snapshot = await sandbox.snapshot();
-            return snapshot.snapshotId;
-          }
-        );
-      } finally {
-        try {
-          await sandbox.stop();
-        } catch {
-        }
-      }
-    }
-  );
-}
-async function withBuildLock(profileHash, callback, canUseCachedSnapshot, hooks) {
-  const state = getStateAdapter();
-  await state.connect();
-  const lockKey = profileLockKey(profileHash);
-  const tryAcquireLock = async () => await state.acquireLock(lockKey, SNAPSHOT_BUILD_LOCK_TTL_MS);
-  let lock = await tryAcquireLock();
-  if (lock) {
-    try {
-      const result = await callback();
-      return {
-        snapshotId: result.snapshotId,
-        source: result.source,
-        waitedForLock: false
-      };
-    } finally {
-      await state.releaseLock(lock);
-    }
-  }
-  return await withSnapshotSpan(
-    "sandbox.snapshot.lock_wait",
-    "sandbox.snapshot.lock_wait",
-    {
-      "app.sandbox.snapshot.profile_hash": profileHash
-    },
-    async () => {
-      await hooks?.onWaitingForLock?.();
-      const waitUntil = Date.now() + SNAPSHOT_WAIT_FOR_LOCK_MS;
-      while (Date.now() < waitUntil) {
-        const cached2 = await getCachedSnapshot(profileHash);
-        if (cached2?.snapshotId && canUseCachedSnapshot(cached2)) {
-          return {
-            snapshotId: cached2.snapshotId,
-            source: "wait_cache",
-            waitedForLock: true
-          };
-        }
-        lock = await tryAcquireLock();
-        if (lock) {
-          try {
-            const result = await callback();
-            return {
-              snapshotId: result.snapshotId,
-              source: result.source,
-              waitedForLock: true
-            };
-          } finally {
-            await state.releaseLock(lock);
-          }
-        }
-        await sleep(500);
-      }
-      const cached = await getCachedSnapshot(profileHash);
-      if (cached?.snapshotId && canUseCachedSnapshot(cached)) {
-        return {
-          snapshotId: cached.snapshotId,
-          source: "wait_cache",
-          waitedForLock: true
-        };
-      }
-      throw new Error("Timed out waiting for snapshot build lock");
-    }
-  );
-}
-function toResolveOutcome(forceRebuild, source, waitedForLock) {
-  if (source === "built") {
-    return forceRebuild ? "forced_rebuild" : "rebuilt";
-  }
-  if (waitedForLock || source === "wait_cache") {
-    return "cache_hit_after_lock_wait";
-  }
-  return "cache_hit";
-}
-function getRebuildReason(params) {
-  if (params.forceRebuild) {
-    return params.staleSnapshotId ? "snapshot_missing" : "force_rebuild";
-  }
-  if (params.cached?.snapshotId && params.shouldRebuildCached) {
-    return "floating_stale";
-  }
-  if (!params.cached?.snapshotId) {
-    return "cache_miss";
-  }
-  return void 0;
-}
-async function resolveRuntimeDependencySnapshot(params) {
-  return await withSnapshotSpan(
-    "sandbox.snapshot.resolve",
-    "sandbox.snapshot.resolve",
-    {
-      "app.sandbox.runtime": params.runtime,
-      "app.sandbox.snapshot.force_rebuild": Boolean(params.forceRebuild)
-    },
-    async () => {
-      await params.onProgress?.("resolve_start");
-      const resolveStartedAtMs = Date.now();
-      const profile = buildDependencyProfile(params.runtime);
-      if (!profile) {
-        return {
-          dependencyCount: 0,
-          cacheHit: false,
-          resolveOutcome: "no_profile"
-        };
-      }
-      const cached = await getCachedSnapshot(profile.profileHash);
-      const cachedNeedsRebuild = Boolean(
-        cached?.snapshotId && shouldRebuildCachedSnapshot(profile, cached)
-      );
-      if (!params.forceRebuild && cached?.snapshotId && !cachedNeedsRebuild) {
-        await params.onProgress?.("cache_hit");
-        return {
-          snapshotId: cached.snapshotId,
-          profileHash: profile.profileHash,
-          dependencyCount: profile.dependencyCount,
-          cacheHit: true,
-          resolveOutcome: "cache_hit"
-        };
-      }
-      const rebuildReason = getRebuildReason({
-        forceRebuild: params.forceRebuild,
-        staleSnapshotId: params.staleSnapshotId,
-        cached,
-        shouldRebuildCached: cachedNeedsRebuild
-      });
-      const canUseCachedSnapshot = (candidate) => {
-        if (params.forceRebuild) {
-          if (params.staleSnapshotId) {
-            return candidate.snapshotId !== params.staleSnapshotId;
-          }
-          return candidate.createdAtMs > resolveStartedAtMs;
-        }
-        return !shouldRebuildCachedSnapshot(profile, candidate);
-      };
-      const lockResult = await withBuildLock(
-        profile.profileHash,
-        async () => {
-          const latest = await getCachedSnapshot(profile.profileHash);
-          if (latest?.snapshotId && canUseCachedSnapshot(latest)) {
-            await params.onProgress?.("cache_hit");
-            return {
-              snapshotId: latest.snapshotId,
-              source: "callback_cache"
-            };
-          }
-          await params.onProgress?.("building_snapshot");
-          const nextSnapshotId = await createDependencySnapshot(
-            profile,
-            params.runtime,
-            params.timeoutMs
-          );
-          await setCachedSnapshot({
-            profileHash: profile.profileHash,
-            snapshotId: nextSnapshotId,
-            runtime: params.runtime,
-            createdAtMs: Date.now(),
-            dependencyCount: profile.dependencyCount
-          });
-          await params.onProgress?.("build_complete");
-          return { snapshotId: nextSnapshotId, source: "built" };
-        },
-        canUseCachedSnapshot,
-        {
-          onWaitingForLock: async () => {
-            await params.onProgress?.("waiting_for_lock");
-          }
-        }
-      );
-      return {
-        snapshotId: lockResult.snapshotId,
-        profileHash: profile.profileHash,
-        dependencyCount: profile.dependencyCount,
-        cacheHit: lockResult.source !== "built",
-        resolveOutcome: toResolveOutcome(
-          Boolean(params.forceRebuild),
-          lockResult.source,
-          lockResult.waitedForLock
-        ),
-        ...rebuildReason ? { rebuildReason } : {}
-      };
-    }
-  );
-}
-function isSnapshotMissingError(error) {
-  const searchable = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-  return searchable.includes("snapshot") && (searchable.includes("not found") || searchable.includes("unknown") || searchable.includes("404"));
-}
-
 export {
+  toOptionalTrimmed,
+  parseSlackThreadId,
+  resolveSlackChannelIdFromThreadId,
+  resolveSlackChannelIdFromMessage,
+  resolveConversationPrivacy,
+  canExposeConversationPayload,
+  toGenAiMessageMetadata,
+  toGenAiTextMetadata,
+  toGenAiPayloadMetadata,
+  toGenAiPayloadTraceAttributes,
+  toGenAiMessagesTraceAttributes,
   GEN_AI_PROVIDER_NAME,
+  GEN_AI_SERVER_ADDRESS,
+  GEN_AI_SERVER_PORT,
   MISSING_GATEWAY_CREDENTIALS_ERROR,
   getGatewayApiKey,
   getPiGatewayApiKeyOverride,
   resolveGatewayModel,
   completeText,
   completeObject,
+  getChatConfig,
   botConfig,
   getSlackBotToken,
   getSlackSigningSecret,
@@ -1382,18 +925,7 @@ export {
   getSlackClientSecret,
   getRuntimeMetadata,
   ACTIVE_LOCK_TTL_MS,
+  getConnectedStateContext,
   getStateAdapter,
-  disconnectStateAdapter,
-  SANDBOX_WORKSPACE_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_DATA_ROOT,
-  sandboxSkillDir,
-  sandboxSkillFile,
-  buildNonInteractiveShellScript,
-  runNonInteractiveCommand,
-  getVercelSandboxCredentials,
-  createSandboxInstance,
-  getRuntimeDependencyProfileHash,
-  resolveRuntimeDependencySnapshot,
-  isSnapshotMissingError
+  disconnectStateAdapter
 };