@sentry/junior 0.109.0 → 0.111.0

package/dist/chat/{runtime → tools/sandbox}/generated-artifacts.d.ts

@@ -1,8 +1,8 @@
 import type { FileUpload } from "chat";
 import { type GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads";
 import type { SandboxCommandResult } from "@/chat/sandbox/workspace";
-/** Sandbox operations needed to make generated artifacts visible to later tools. */
-export interface GeneratedArtifactSandbox {
+/** Workspace operations needed to make generated artifacts visible to later tools. */
+export interface GeneratedArtifactWorkspace {
     runCommand(input: {
         args?: string[];
         cmd: string;
@@ -13,4 +13,4 @@ export interface GeneratedArtifactSandbox {
     }>): Promise<void>;
 }
 /** Persist generated artifacts into the sandbox before returning model-visible handles. */
-export declare function writeSandboxGeneratedArtifacts(sandbox: GeneratedArtifactSandbox, files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;
+export declare function writeSandboxGeneratedArtifacts(workspace: GeneratedArtifactWorkspace, files: FileUpload[]): Promise<GeneratedArtifactFileRef[]>;

package/dist/chat/tools/types.d.ts

@@ -69,7 +69,7 @@ interface BaseToolRuntimeContext {
     configuration?: Record<string, unknown>;
     egress: PluginEgress;
     mcpToolManager?: McpToolManager;
-    sandbox: SandboxWorkspace;
+    workspace: SandboxWorkspace;
 }
 interface SlackToolRuntimeContext extends BaseToolRuntimeContext {
     destination: SlackDestination;

package/dist/chat/tools/web/fetch-content.d.ts

@@ -17,6 +17,11 @@ export type WebFetchResponse = {
     extracted_chars: number;
     truncated: boolean;
 } & Record<string, unknown>;
+/** Apply the web-fetch character limit to already extracted text content. */
+export declare function truncateWebFetchContent(content: string, maxChars: number): {
+    content: string;
+    truncated: boolean;
+};
 /** Extract readable content and metadata from a fetched response body. */
 export declare function extractContentDetails(body: string, contentType: string, maxChars: number): WebFetchResponseContent;
 /** Extract readable content from a fetched response body, converting HTML to markdown. */

package/dist/chat/tools/web/image-generate.d.ts

@@ -1,6 +1,7 @@
 import type { ImageGenerateToolDeps, ToolHooks } from "@/chat/tools/types";
 /** Create the image tool with sandbox artifact guidance matched to file-send capability. */
-export declare function createImageGenerateTool(hooks: Required<Pick<ToolHooks, "writeGeneratedArtifacts">>, options?: {
+export declare function createImageGenerateTool(hooks: Required<Pick<ToolHooks, "writeGeneratedArtifacts">>, options: {
+    modelId: string;
     canSendFilesToActiveConversation?: boolean;
 }, deps?: ImageGenerateToolDeps): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../definition").JsonSchemaObject;

package/dist/chat/tools/web/search.d.ts

@@ -1,5 +1,5 @@
 import type { WebSearchToolDeps } from "@/chat/tools/types";
-export declare function createWebSearchTool(override?: WebSearchToolDeps): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+export declare function createWebSearchTool(modelId: string, override?: WebSearchToolDeps): Omit<import("../definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("../definition").JsonSchemaObject;
     outputSchema: import("../definition").JsonSchemaObject;
     prepareArguments(args: unknown): {

package/dist/{chunk-CEA3A3UA.js → chunk-2ZTTXTSZ.js}

@@ -59,12 +59,35 @@ var pluginOperationalRecordSetSchema = z.object({
   records: z.array(pluginOperationalRecordSchema).optional(),
   title: z.string()
 }).strict();
+var pluginOperationalBarChartWidgetSchema = z.object({
+  categories: z.array(
+    z.object({
+      id: z.string().min(1),
+      label: z.string().min(1),
+      values: z.record(z.string(), z.number().finite())
+    }).strict()
+  ).max(100),
+  description: z.string().optional(),
+  emptyText: z.string().optional(),
+  id: z.string().min(1),
+  series: z.array(
+    z.object({
+      key: z.string().min(1),
+      label: z.string().min(1),
+      tone: pluginOperationalToneSchema.optional()
+    }).strict()
+  ).min(1).max(8),
+  timeRangeDays: z.array(z.union([z.literal(7), z.literal(30), z.literal(90)])).min(1).max(3).optional(),
+  title: z.string().min(1),
+  type: z.literal("bar_chart")
+}).strict();
 var pluginOperationalReportSchema = z.object({
   generatedAt: z.string().optional(),
   metrics: z.array(pluginOperationalMetricSchema).optional(),
   recordSets: z.array(pluginOperationalRecordSetSchema).optional(),
   title: z.string().optional(),
-  pluginName: z.string()
+  pluginName: z.string(),
+  widgets: z.array(pluginOperationalBarChartWidgetSchema).max(12).optional()
 }).strict();
 var pluginOperationalReportFeedSchema = z.object({
   generatedAt: z.string(),

package/dist/{chunk-IVVGFRQQ.js → chunk-42WRQLJ6.js}

@@ -1,34 +1,12 @@
-import {
-  JUNIOR_VERSION
-} from "./chunk-OCD3OZRK.js";
-
-// src/deployment.ts
-var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
-var JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
-var JUNIOR_RETENTION_ROUTE = "/api/internal/retention";
-var JUNIOR_RETENTION_CRON_SCHEDULE = "0 4 * * *";
-var JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
-var JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE = "/api/internal/plugin/tasks";
-var LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
-function toOptionalTrimmed(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : void 0;
+// src/chat/coerce.ts
+function toOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
 }
-function getDeploymentServiceVersion() {
-  return toOptionalTrimmed(process.env.SENTRY_RELEASE) ?? toOptionalTrimmed(process.env.VERCEL_GIT_COMMIT_SHA);
+function toOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function getDeploymentTelemetryAttributes() {
-  const attributes = {};
-  const serviceVersion = getDeploymentServiceVersion();
-  const deploymentId = toOptionalTrimmed(process.env.VERCEL_DEPLOYMENT_ID);
-  attributes["app.junior.version"] = JUNIOR_VERSION;
-  if (serviceVersion) {
-    attributes["service.version"] = serviceVersion;
-  }
-  if (deploymentId) {
-    attributes["deployment.id"] = deploymentId;
-  }
-  return attributes;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
 
 // src/chat/slack/timestamp.ts
@@ -82,15 +60,9 @@ function parseSlackUserId(value) {
 }
 
 export {
-  JUNIOR_HEARTBEAT_ROUTE,
-  JUNIOR_HEARTBEAT_CRON_SCHEDULE,
-  JUNIOR_RETENTION_ROUTE,
-  JUNIOR_RETENTION_CRON_SCHEDULE,
-  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
-  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
-  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION,
-  getDeploymentServiceVersion,
-  getDeploymentTelemetryAttributes,
+  toOptionalString,
+  toOptionalNumber,
+  isRecord,
   parseSlackMessageTs,
   parseSlackChannelId,
   parseSlackChannelReferenceId,

package/dist/{chunk-O3JMSZLI.js → chunk-6Y5L4BOM.js}

@@ -1,11 +1,9 @@
-import {
-  toOptionalString
-} from "./chunk-OB42YVAE.js";
 import {
   parseSlackChannelId,
   parseSlackMessageTs,
-  parseSlackTeamId
-} from "./chunk-IVVGFRQQ.js";
+  parseSlackTeamId,
+  toOptionalString
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/conversation-privacy.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-HO5NT6OE.js → chunk-B45FPP2A.js}

@@ -1,19 +1,21 @@
 import {
   SANDBOX_WORKSPACE_ROOT,
   getStateAdapter
-} from "./chunk-OUHNWH46.js";
+} from "./chunk-PYKKM4MM.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
 import {
   toOptionalTrimmed
-} from "./chunk-JNAVF45E.js";
+} from "./chunk-NQLWOTY4.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-3SXUV423.js";
+} from "./chunk-WSRBFHPX.js";
 import {
+  setSpanAttributes,
+  setSpanStatus,
   withSpan
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-J7APPQIJ.js";
 
 // src/chat/sandbox/runtime-dependencies.ts
 var GLOBAL_RUNTIME_DEPENDENCIES = [
@@ -105,37 +107,303 @@ function getVercelSandboxCredentials() {
 }
 
 // src/chat/sandbox/workspace.ts
-function createSandboxInstance(sandbox) {
+import {
+  FileSystem
+} from "@vercel/sandbox";
+
+// src/chat/sandbox/http-error-details.ts
+var DEFAULT_PREVIEW_LIMIT = 512;
+function toTrimmedString(value, maxChars) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}\u2026` : normalized;
+}
+function extractHttpErrorDetails(error, options = {}) {
+  const prefix = options.attributePrefix ?? "app.http_error";
+  const previewLimit = options.previewLimit ?? DEFAULT_PREVIEW_LIMIT;
+  const normalizedError = error instanceof Error ? error : new Error(String(error));
+  const err = error ?? {};
+  const attributes = {
+    "error.type": normalizedError.name || "Error",
+    "exception.message": toTrimmedString(normalizedError.message, previewLimit) ?? "HTTP error"
+  };
+  const response = err.response;
+  const statusCode = typeof response?.status === "number" ? response.status : void 0;
+  const statusText = toTrimmedString(response?.statusText, previewLimit);
+  const responseUrl = toTrimmedString(response?.url, previewLimit);
+  const responseText = toTrimmedString(err.text, previewLimit);
+  const responseJson = toTrimmedString(
+    err.json && typeof err.json === "object" ? JSON.stringify(err.json) : void 0,
+    previewLimit
+  );
+  const contentType = toTrimmedString(
+    response?.headers?.get?.("content-type"),
+    previewLimit
+  );
+  const requestIdHeader = toTrimmedString(
+    response?.headers?.get?.("x-request-id"),
+    previewLimit
+  );
+  const vercelIdHeader = toTrimmedString(
+    response?.headers?.get?.("x-vercel-id"),
+    previewLimit
+  );
+  const requestId = requestIdHeader ?? vercelIdHeader;
+  if (statusCode !== void 0) {
+    attributes["http.response.status_code"] = statusCode;
+  }
+  if (statusText) {
+    attributes[`${prefix}.status_text`] = statusText;
+  }
+  if (responseUrl) {
+    attributes["url.full"] = responseUrl;
+  }
+  if (contentType) {
+    attributes["http.response.header.content-type"] = [contentType];
+  }
+  if (requestIdHeader) {
+    attributes["http.response.header.x-request-id"] = [requestIdHeader];
+  }
+  if (vercelIdHeader) {
+    attributes["http.response.header.x-vercel-id"] = [vercelIdHeader];
+  }
+  if (responseText) {
+    attributes[`${prefix}.response_text_preview`] = responseText;
+    attributes[`${prefix}.response_text_length`] = responseText.length;
+  }
+  if (responseJson) {
+    attributes[`${prefix}.response_json_preview`] = responseJson;
+  }
+  const summaryParts = [];
+  if (statusCode !== void 0) {
+    summaryParts.push(`status=${statusCode}`);
+  }
+  if (statusText) {
+    summaryParts.push(`statusText=${statusText}`);
+  }
+  if (responseUrl) {
+    summaryParts.push(`url=${responseUrl}`);
+  }
+  if (requestId) {
+    summaryParts.push(`requestId=${requestId}`);
+  }
+  for (const field of options.extraFields ?? []) {
+    const value = toTrimmedString(err[field.sourceKey], previewLimit);
+    if (!value) {
+      continue;
+    }
+    attributes[`${prefix}.${field.attributeKey}`] = value;
+    summaryParts.push(`${field.summaryKey ?? field.attributeKey}=${value}`);
+  }
+  if (responseJson) {
+    summaryParts.push(`json=${responseJson}`);
+  } else if (responseText) {
+    summaryParts.push(`text=${responseText}`);
+  }
+  const searchableText = `${normalizedError.message} ${responseText ?? ""} ${responseJson ?? ""}`.toLowerCase();
+  return {
+    attributes,
+    summary: summaryParts.join(", "),
+    searchableText
+  };
+}
+
+// src/chat/sandbox/errors.ts
+var SANDBOX_ERROR_FIELDS = [
+  {
+    sourceKey: "sandboxId",
+    attributeKey: "sandbox_id",
+    summaryKey: "sandboxId"
+  }
+];
+function getSandboxErrorDetails(error) {
+  return extractHttpErrorDetails(error, {
+    attributePrefix: "app.sandbox.api_error",
+    extraFields: [...SANDBOX_ERROR_FIELDS]
+  });
+}
+function findInErrorChain(error, predicate) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (predicate(current)) {
+      return true;
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInvalidSandboxSessionError(error) {
+  if (!isRecord(error)) {
+    return false;
+  }
+  if (isRecord(error.json) && error.json.invalidToken === true) {
+    return true;
+  }
+  const response = error.response;
+  return isRecord(response) && response.status === 403 && typeof response.url === "string" && response.url.includes("/sandboxes/sessions");
+}
+function getFirstErrorMessage(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (current instanceof Error) {
+      const message = current.message.trim();
+      if (message) {
+        return message;
+      }
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return void 0;
+}
+function isAlreadyExistsError(error) {
+  const details = getSandboxErrorDetails(error);
+  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+}
+function isSandboxUnavailableError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (isInvalidSandboxSessionError(candidate)) {
+      return true;
+    }
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available") || searchable.includes("stream was closed and is not accepting commands");
+  });
+}
+function isSandboxMissingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("status=404") || searchable.includes("status code 404") || searchable.includes("snapshot_not_found");
+  });
+}
+function isSnapshottingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
+  });
+}
+function isSandboxCommandStreamInterruptedError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (!(candidate instanceof Error)) {
+      return false;
+    }
+    return candidate.name === "StreamError" && candidate.message.toLowerCase().includes("stream ended before command finished");
+  });
+}
+function wrapSandboxSetupError(error) {
+  try {
+    const details = getSandboxErrorDetails(error);
+    if (details.summary) {
+      return new Error(`sandbox setup failed (${details.summary})`, {
+        cause: error
+      });
+    }
+  } catch {
+  }
+  let causeMessage;
+  try {
+    causeMessage = getFirstErrorMessage(error);
+  } catch (cause) {
+    causeMessage = cause instanceof Error ? cause.message : void 0;
+  }
+  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
+    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
+    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
+  }
+  return new Error("sandbox setup failed", { cause: error });
+}
+function throwSandboxOperationError(action, error, includeMissingPath = false) {
+  const details = getSandboxErrorDetails(error);
+  setSpanAttributes({
+    ...details.attributes,
+    ...includeMissingPath ? {
+      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
+    } : {},
+    "app.sandbox.success": false
+  });
+  setSpanStatus("error");
+  throw new Error(
+    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
+    {
+      cause: error
+    }
+  );
+}
+
+// src/chat/sandbox/workspace.ts
+function createSandboxSession(sandbox, options) {
+  const session = sandbox.currentSession();
+  const fileSystem = new FileSystem(session);
+  const run = async (operation) => {
+    try {
+      return await operation();
+    } catch (error) {
+      if (isSandboxUnavailableError(error)) {
+        options?.onUnavailable?.(session.sessionId);
+      }
+      throw error;
+    }
+  };
+  const fs = {
+    readFile: async (filePath, readOptions) => await run(async () => await fileSystem.readFile(filePath, readOptions)),
+    writeFile: async (filePath, content, writeOptions) => await run(
+      async () => await fileSystem.writeFile(filePath, content, writeOptions)
+    ),
+    readdir: async (filePath) => await run(async () => await fileSystem.readdir(filePath)),
+    stat: async (filePath) => await run(async () => await fileSystem.stat(filePath))
+  };
   return {
     sandboxId: sandbox.name,
-    get sandboxEgressId() {
-      return sandbox.currentSession().sessionId;
-    },
-    fs: sandbox.fs,
+    sessionId: session.sessionId,
+    fs,
     extendTimeout(duration) {
-      return sandbox.extendTimeout(duration);
+      return run(async () => await session.extendTimeout(duration));
     },
     mkDir(path) {
-      return sandbox.mkDir(path);
+      return run(async () => await session.mkDir(path));
     },
     readFileToBuffer(input) {
-      return sandbox.readFileToBuffer(input);
+      return run(async () => await session.readFileToBuffer(input));
     },
-    runCommand(input) {
-      return sandbox.runCommand(input);
+    async runCommand(input) {
+      const result = await run(async () => await session.runCommand(input));
+      const [stdout, stderr] = await Promise.all([
+        run(async () => await result.stdout()),
+        run(async () => await result.stderr())
+      ]);
+      return {
+        exitCode: result.exitCode,
+        stdout,
+        stderr
+      };
     },
-    async snapshot() {
-      const snapshot = await sandbox.snapshot();
-      return { snapshotId: snapshot.snapshotId };
+    snapshot() {
+      return run(async () => {
+        const snapshot = await session.snapshot();
+        return { snapshotId: snapshot.snapshotId };
+      });
     },
     stop() {
-      return sandbox.stop();
+      return run(async () => await session.stop());
     },
     update(params) {
-      return sandbox.update(params);
+      return run(async () => await session.update(params));
     },
     writeFiles(files) {
-      return sandbox.writeFiles(files);
+      return run(async () => await session.writeFiles(files));
     }
   };
 }
@@ -258,8 +526,8 @@ async function runOrThrow(sandbox, params, label) {
   if (result.exitCode === 0) {
     return;
   }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
   const detail = stderr || stdout || "command failed";
   throw new Error(`${label} failed: ${detail}`);
 }
@@ -268,8 +536,8 @@ async function tryRun(sandbox, params) {
   if (result.exitCode === 0) {
     return { ok: true };
   }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
   return { ok: false, detail: stderr || stdout || "command failed" };
 }
 async function installGhCliViaDnf(sandbox) {
@@ -368,8 +636,8 @@ async function installRuntimeDependencies(sandbox, deps) {
               cmd: "sha256sum",
               args: [rpmPath]
             });
-            const checksumStdout = (await checksumResult.stdout()).trim();
-            const checksumStderr = (await checksumResult.stderr()).trim();
+            const checksumStdout = checksumResult.stdout.trim();
+            const checksumStderr = checksumResult.stderr.trim();
             if (checksumResult.exitCode !== 0) {
               throw new Error(
                 `sha256sum failed: ${checksumStderr || checksumStdout || "command failed"}`
@@ -460,8 +728,8 @@ async function runRuntimePostinstall(sandbox, commands) {
         if (result.exitCode === 0) {
           continue;
         }
-        const stderr = (await result.stderr()).trim();
-        const stdout = (await result.stdout()).trim();
+        const stderr = result.stderr.trim();
+        const stdout = result.stdout.trim();
         const detail = stderr || stdout || "command failed";
         throw new Error(`runtime-postinstall ${command.cmd} failed: ${detail}`);
       }
@@ -479,7 +747,7 @@ async function createDependencySnapshot(profile, runtime, timeoutMs) {
     async () => {
       const sandboxCredentials = getVercelSandboxCredentials();
       const resources = getSandboxResources();
-      const sandbox = createSandboxInstance(
+      const sandbox = createSandboxSession(
         await Sandbox.create({
           timeout: timeoutMs,
           runtime,
@@ -697,12 +965,19 @@ function isSnapshotMissingError(error) {
 }
 
 export {
+  isAlreadyExistsError,
+  isSandboxUnavailableError,
+  isSandboxMissingError,
+  isSnapshottingError,
+  isSandboxCommandStreamInterruptedError,
+  wrapSandboxSetupError,
+  throwSandboxOperationError,
+  getVercelSandboxCredentials,
   buildNonInteractiveShellScript,
   runNonInteractiveCommand,
-  getVercelSandboxCredentials,
   getSandboxResources,
   GLOBAL_RUNTIME_DEPENDENCIES,
-  createSandboxInstance,
+  createSandboxSession,
   getRuntimeDependencyProfileHash,
   resolveRuntimeDependencySnapshot,
   isSnapshotMissingError

package/dist/{chunk-WHMOBKT7.js → chunk-BTRNMS6A.js}

@@ -1,9 +1,9 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-3SXUV423.js";
+} from "./chunk-WSRBFHPX.js";
 import {
   logWarn
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-J7APPQIJ.js";
 import {
   skillRoots
 } from "./chunk-3V7OFJZC.js";

package/dist/{chunk-PLB7MRCQ.js → chunk-C4MZ3GP5.js}

@@ -1,6 +1,6 @@
 import {
   parseSlackTeamId
-} from "./chunk-IVVGFRQQ.js";
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/actor.ts
 import { z } from "zod";