@sentry/junior 0.68.0 → 0.70.0

package/dist/{chunk-EBVQXCD2.js → chunk-JS4HURDT.js}

@@ -6,7 +6,7 @@ import {
   setSpanAttributes,
   toOptionalString,
   withSpan
-} from "./chunk-OIIXZOOC.js";
+} from "./chunk-BBXYXOJW.js";
 
 // src/chat/slack/context.ts
 function toTrimmedSlackString(value) {
@@ -230,6 +230,316 @@ import {
   streamAnthropic,
   streamSimpleAnthropic
 } from "@earendil-works/pi-ai/anthropic";
+
+// src/chat/turn-context-tag.ts
+var TURN_CONTEXT_TAG = "runtime-turn-context";
+
+// src/chat/respond-helpers.ts
+var MAX_INLINE_ATTACHMENT_BASE64_CHARS = 12e4;
+var RUNTIME_TURN_CONTEXT_START = `<${TURN_CONTEXT_TAG}>`;
+function getSessionIdentifiers(context) {
+  return {
+    conversationId: context.correlation?.conversationId ?? context.correlation?.threadId ?? context.correlation?.runId,
+    sessionId: context.correlation?.turnId
+  };
+}
+function isExecutionDeferralResponse(text) {
+  return /\b(want me to proceed|do you want me to proceed|shall i proceed|can i proceed|should i proceed|let me do that now|give me a moment|tag me again|fresh invocation)\b/i.test(
+    text
+  );
+}
+function isToolAccessDisclaimerResponse(text) {
+  return /\b(i (don't|do not) have access to (active )?tool|tool results came back empty|prior results .* empty|cannot access .*tool|need to (run|load) .*tool .* first)\b/i.test(
+    text
+  );
+}
+function isExecutionEscapeResponse(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  return isExecutionDeferralResponse(trimmed) || isToolAccessDisclaimerResponse(trimmed);
+}
+function parseJsonCandidate(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    if (!fenced) return void 0;
+    try {
+      return JSON.parse(fenced[1]);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function isToolPayloadShape(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const record = payload;
+  const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+  if (type.startsWith("tool-")) return true;
+  if (type === "tool_use" || type === "tool_call" || type === "tool_result" || type === "tool_error")
+    return true;
+  const hasToolName = typeof record.toolName === "string" || typeof record.name === "string";
+  const hasToolInput = Object.prototype.hasOwnProperty.call(record, "input") || Object.prototype.hasOwnProperty.call(record, "args");
+  if (hasToolName && hasToolInput) return true;
+  return false;
+}
+function isRawToolPayloadResponse(text) {
+  const parsed = parseJsonCandidate(text);
+  if (Array.isArray(parsed)) {
+    return parsed.some((entry) => isToolPayloadShape(entry));
+  }
+  if (isToolPayloadShape(parsed)) {
+    return true;
+  }
+  const compact = text.replace(/\s+/g, " ");
+  return /"type"\s*:\s*"tool[-_](use|call|result|error)"/i.test(compact);
+}
+function toObservablePromptPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text
+    };
+  }
+  return {
+    type: "image",
+    mimeType: part.mimeType,
+    data: `[omitted:${part.data.length}]`
+  };
+}
+function summarizeMessageText(text) {
+  const normalized = text.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return "[empty]";
+  }
+  return normalized.length > 1200 ? `${normalized.slice(0, 1200)}...` : normalized;
+}
+function isStructuredThreadContext(context) {
+  return /^<thread-(compactions|transcript)>/.test(context);
+}
+function renderThreadContextForPrompt(context) {
+  if (isStructuredThreadContext(context)) {
+    return context;
+  }
+  return ["<thread-background>", context, "</thread-background>"].join("\n");
+}
+function buildUserTurnText(userInput, conversationContext) {
+  const trimmedContext = conversationContext?.trim();
+  if (!trimmedContext) {
+    return userInput;
+  }
+  return [
+    renderThreadContextForPrompt(trimmedContext),
+    "",
+    "<current-instruction>",
+    userInput,
+    "</current-instruction>"
+  ].join("\n");
+}
+function encodeNonImageAttachmentForPrompt(attachment) {
+  const base64 = attachment.data.toString("base64");
+  const wasTruncated = base64.length > MAX_INLINE_ATTACHMENT_BASE64_CHARS;
+  const encodedPayload = wasTruncated ? `${base64.slice(0, MAX_INLINE_ATTACHMENT_BASE64_CHARS)}...` : base64;
+  return [
+    "<attachment>",
+    `filename: ${attachment.filename ?? "unnamed"}`,
+    `media_type: ${attachment.mediaType}`,
+    "encoding: base64",
+    `truncated: ${wasTruncated ? "true" : "false"}`,
+    "<data_base64>",
+    encodedPayload,
+    "</data_base64>",
+    "</attachment>"
+  ].join("\n");
+}
+function isToolResultMessage(value) {
+  return typeof value === "object" && value !== null && value.role === "toolResult";
+}
+function normalizeToolNameFromResult(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const record = result;
+  if (typeof record.toolName === "string" && record.toolName.length > 0) {
+    return record.toolName;
+  }
+  if (typeof record.name === "string" && record.name.length > 0) {
+    return record.name;
+  }
+  return void 0;
+}
+function isToolResultError(result) {
+  if (!result || typeof result !== "object") return false;
+  return Boolean(result.isError);
+}
+function isAssistantMessage(value) {
+  return typeof value === "object" && value !== null && value.role === "assistant";
+}
+function getPiMessageRole(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const role = value.role;
+  return typeof role === "string" ? role : void 0;
+}
+function getUserMessageContent(message) {
+  const record = message;
+  return record.role === "user" && Array.isArray(record.content) ? record.content : void 0;
+}
+function isRuntimeTurnContextPart(part, marker) {
+  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.startsWith(marker);
+}
+function prependRuntimeTurnContext(message, turnContextPrompt) {
+  const content = getUserMessageContent(message);
+  if (!content) {
+    return void 0;
+  }
+  const contextIndex = content.findIndex(
+    (part) => isRuntimeTurnContextPart(part, RUNTIME_TURN_CONTEXT_START)
+  );
+  if (contextIndex >= 0) {
+    return void 0;
+  }
+  return {
+    ...message,
+    content: [{ type: "text", text: turnContextPrompt }, ...content]
+  };
+}
+function prependMissingRuntimeTurnContext(messages, turnContextPrompt) {
+  if (hasRuntimeTurnContext(messages)) {
+    return messages;
+  }
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const updated = prependRuntimeTurnContext(
+      messages[index],
+      turnContextPrompt
+    );
+    if (!updated) {
+      continue;
+    }
+    const nextMessages = [...messages];
+    nextMessages[index] = updated;
+    return nextMessages;
+  }
+  return [
+    ...messages,
+    {
+      role: "user",
+      content: [{ type: "text", text: turnContextPrompt }],
+      timestamp: Date.now()
+    }
+  ];
+}
+function hasRuntimeTurnContext(messages) {
+  return messages.some(
+    (message) => getUserMessageContent(message)?.some(
+      (part) => isRuntimeTurnContextPart(part, RUNTIME_TURN_CONTEXT_START)
+    )
+  );
+}
+function stripRuntimeTurnContext(messages) {
+  return messages.flatMap((message) => {
+    const content = getUserMessageContent(message);
+    if (!content) {
+      return [message];
+    }
+    const nextContent = content.filter(
+      (part) => !isRuntimeTurnContextPart(part, RUNTIME_TURN_CONTEXT_START)
+    );
+    if (nextContent.length === content.length) {
+      return [message];
+    }
+    if (nextContent.length === 0) {
+      return [];
+    }
+    return [{ ...message, content: nextContent }];
+  });
+}
+function extractAssistantText(message) {
+  const content = message.content ?? [];
+  return content.filter(
+    (part) => part.type === "text" && typeof part.text === "string"
+  ).map((part) => part.text).join("\n");
+}
+function getTerminalAssistantMessages(messages) {
+  let lastToolResultIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (isToolResultMessage(messages[index])) {
+      lastToolResultIndex = index;
+      break;
+    }
+  }
+  return messages.slice(lastToolResultIndex + 1).filter(isAssistantMessage);
+}
+function upsertActiveSkill(activeSkills, next) {
+  const existing = activeSkills.find((skill) => skill.name === next.name);
+  if (existing) {
+    existing.body = next.body;
+    existing.description = next.description;
+    existing.skillPath = next.skillPath;
+    existing.allowedTools = next.allowedTools;
+    existing.pluginProvider = next.pluginProvider;
+    return;
+  }
+  activeSkills.push(next);
+}
+function trimTrailingAssistantMessages(messages) {
+  let end = messages.length;
+  while (end > 0 && getPiMessageRole(messages[end - 1]) === "assistant") {
+    end -= 1;
+  }
+  return end === messages.length ? [...messages] : messages.slice(0, end);
+}
+
+// src/chat/services/provider-retry.ts
+var PROVIDER_RETRY_DELAYS_MS = [2e3, 4e3, 8e3];
+var PROVIDER_ERROR_PREFIX = "AI provider error:";
+var PROVIDER_RETRY_ERROR_NAME = "ProviderRetryError";
+var NON_RETRYABLE_PROVIDER_ERROR_PATTERNS = [
+  /invalid.?api.?key|no api key|authentication|authorization|permission|forbidden|credential/i,
+  /context.?length|context.?window/i,
+  /content.?policy|validation|bad request|\b(?:400|401|403)\b/i,
+  /unsupported model|invalid model|unknown ai gateway model|unknown model|mismatched api/i,
+  /usage limit|monthly usage limit|available balance|insufficient.?quota|out of budget|quota exceeded|billing/i
+];
+function providerMessage(error) {
+  return (error instanceof Error ? error.message : String(error)).trim();
+}
+function createProviderError(error) {
+  const message = providerMessage(error);
+  const displayMessage = `${PROVIDER_ERROR_PREFIX} ${message || "Unknown provider error"}`;
+  const providerError = new Error(displayMessage, { cause: error });
+  if (message && isRetryableProviderFailure(message)) {
+    providerError.name = PROVIDER_RETRY_ERROR_NAME;
+  }
+  return providerError;
+}
+function isProviderRetryError(error) {
+  return error instanceof Error && error.name === PROVIDER_RETRY_ERROR_NAME;
+}
+function isRetryableProviderFailure(errorMessage) {
+  return !NON_RETRYABLE_PROVIDER_ERROR_PATTERNS.some(
+    (pattern) => pattern.test(errorMessage)
+  );
+}
+function nextProviderRetry(args) {
+  const delayMs = PROVIDER_RETRY_DELAYS_MS[args.attempt];
+  const errorMessage = args.lastAssistant?.errorMessage?.trim();
+  if (delayMs === void 0 || args.lastAssistant?.stopReason !== "error" || !errorMessage || !isRetryableProviderFailure(errorMessage)) {
+    return void 0;
+  }
+  const messages = trimTrailingAssistantMessages(args.messages);
+  if (messages.length === args.messages.length) {
+    return void 0;
+  }
+  const tailRole = getPiMessageRole(messages.at(-1));
+  if (tailRole !== "user" && tailRole !== "toolResult") {
+    return void 0;
+  }
+  return { delayMs, messages };
+}
+
+// src/chat/pi/client.ts
 registerApiProvider({
   api: "anthropic-messages",
   stream: streamAnthropic,
@@ -250,7 +560,7 @@ function getPiGatewayApiKeyOverride() {
 function extractText(message) {
   return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join("").trim();
 }
-function parseJsonCandidate(text) {
+function parseJsonCandidate2(text) {
   const trimmed = text.trim();
   if (!trimmed) return void 0;
   try {
@@ -357,21 +667,26 @@ async function completeText(params) {
     "gen_ai.chat",
     logContextFromMetadata(params.modelId, params.metadata),
     async () => {
-      const message = await completeSimple(
-        model,
-        {
-          systemPrompt: params.system,
-          messages: params.messages
-        },
-        {
-          ...apiKey ? { apiKey } : {},
-          temperature: params.temperature,
-          maxTokens: params.maxTokens,
-          reasoning: params.thinkingLevel,
-          signal: params.signal,
-          metadata: params.metadata
-        }
-      );
+      let message;
+      try {
+        message = await completeSimple(
+          model,
+          {
+            systemPrompt: params.system,
+            messages: params.messages
+          },
+          {
+            ...apiKey ? { apiKey } : {},
+            temperature: params.temperature,
+            maxTokens: params.maxTokens,
+            reasoning: params.thinkingLevel,
+            signal: params.signal,
+            metadata: params.metadata
+          }
+        );
+      } catch (error) {
+        throw createProviderError(error);
+      }
       const outputText = extractText(message);
       const outputMessagesAttribute = serializeGenAiAttribute(
         messageAttributeMode === "metadata" ? [
@@ -401,17 +716,17 @@ async function completeText(params) {
       };
       setSpanAttributes(endAttributes);
       if (message.stopReason === "error") {
-        const providerMessage = message.errorMessage?.trim() || "Unknown provider error";
+        const providerMessage2 = message.errorMessage?.trim() || "Unknown provider error";
         logWarn(
           "ai_completion_provider_error",
           {},
           {
             ...baseAttributes,
-            "exception.message": providerMessage
+            "exception.message": providerMessage2
           },
           "AI completion returned provider error"
         );
-        throw new Error(`AI provider error: ${providerMessage}`);
+        throw createProviderError(providerMessage2);
       }
       return {
         message,
@@ -454,6 +769,9 @@ async function completeObject(params) {
       ]
     }));
   } catch (error) {
+    if (isProviderRetryError(error)) {
+      throw error;
+    }
     logException(
       error,
       "ai_completion_failed",
@@ -467,7 +785,7 @@ async function completeObject(params) {
     );
     throw error;
   }
-  const candidate = parseJsonCandidate(text);
+  const candidate = parseJsonCandidate2(text);
   const parsed = params.schema.safeParse(candidate);
   if (!parsed.success) {
     const preview = text.length > 400 ? `${text.slice(0, 400)}...` : text;
@@ -727,255 +1045,6 @@ function setSlackReactionConfig(overrides) {
   }
 }
 
-// src/chat/state/adapter.ts
-import { createMemoryState } from "@chat-adapter/state-memory";
-import { createRedisState } from "@chat-adapter/state-redis";
-var ACTIVE_LOCK_TTL_MS = 9e4;
-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 effectiveLockTtlMs = (ttlMs) => Math.max(ttlMs, ACTIVE_LOCK_TTL_MS);
-  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 effectiveTtlMs = effectiveLockTtlMs(ttlMs);
-    const lock = await base.acquireLock(threadId, effectiveTtlMs);
-    if (lock && shouldHeartbeatLock(ttlMs)) {
-      startOrUpdateHeartbeat(lock, effectiveTtlMs);
-    }
-    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 effectiveTtlMs = effectiveLockTtlMs(ttlMs);
-      const extended = await base.extendLock(lock, effectiveTtlMs);
-      if (extended) {
-        lock.expiresAt = Date.now() + effectiveTtlMs;
-        if (shouldHeartbeatLock(ttlMs)) {
-          startOrUpdateHeartbeat(lock, effectiveTtlMs);
-        } 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
-  };
-}
-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;
-  }
-}
-
-// 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`;
-}
-
 export {
   toOptionalTrimmed,
   parseSlackThreadId,
@@ -988,6 +1057,28 @@ export {
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes,
   toGenAiMessagesTraceAttributes,
+  TURN_CONTEXT_TAG,
+  getSessionIdentifiers,
+  isExecutionEscapeResponse,
+  isRawToolPayloadResponse,
+  toObservablePromptPart,
+  summarizeMessageText,
+  buildUserTurnText,
+  encodeNonImageAttachmentForPrompt,
+  isToolResultMessage,
+  normalizeToolNameFromResult,
+  isToolResultError,
+  isAssistantMessage,
+  getPiMessageRole,
+  prependMissingRuntimeTurnContext,
+  hasRuntimeTurnContext,
+  stripRuntimeTurnContext,
+  extractAssistantText,
+  getTerminalAssistantMessages,
+  upsertActiveSkill,
+  trimTrailingAssistantMessages,
+  isProviderRetryError,
+  nextProviderRetry,
   GEN_AI_PROVIDER_NAME,
   GEN_AI_SERVER_ADDRESS,
   GEN_AI_SERVER_PORT,
@@ -1007,14 +1098,5 @@ export {
   getSlackClientSecret,
   getRuntimeMetadata,
   getSlackReactionConfig,
-  setSlackReactionConfig,
-  ACTIVE_LOCK_TTL_MS,
-  getConnectedStateContext,
-  getStateAdapter,
-  disconnectStateAdapter,
-  SANDBOX_WORKSPACE_ROOT,
-  SANDBOX_SKILLS_ROOT,
-  SANDBOX_DATA_ROOT,
-  sandboxSkillDir,
-  sandboxSkillFile
+  setSlackReactionConfig
 };