@sentry/junior 0.109.0 → 0.110.0

package/dist/{chunk-QY636HZU.js → chunk-2T7TIEXI.js}

@@ -1,36 +1,36 @@
 import {
   SANDBOX_WORKSPACE_ROOT,
   getStateAdapter
-} from "./chunk-OUHNWH46.js";
+} from "./chunk-GK47NBDE.js";
 import {
   isConversationChannel,
   isConversationScopedChannel,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-RGX4V75M.js";
+} from "./chunk-L5XQPJ7T.js";
 import {
   getDb
-} from "./chunk-FENLIFJD.js";
+} from "./chunk-4QU44P7Q.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   standardModelId
-} from "./chunk-JNAVF45E.js";
+} from "./chunk-WNOVRQ67.js";
 import {
   isActorUserId,
   parseActorUserId
-} from "./chunk-PLB7MRCQ.js";
+} from "./chunk-C4MZ3GP5.js";
 import {
   logException,
   logInfo,
   logWarn
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-IYKPU7H6.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackMessageTs,
   parseSlackTeamId
-} from "./chunk-IVVGFRQQ.js";
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
@@ -406,6 +406,9 @@ var registeredPlugins = [];
 var PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
 var PLUGIN_TOOL_NAME_RE = /^[a-z][A-Za-z0-9]*$/;
 var OPERATIONAL_REPORT_MAX_METRICS = 8;
+var OPERATIONAL_REPORT_MAX_WIDGETS = 12;
+var OPERATIONAL_REPORT_MAX_CHART_SERIES = 8;
+var OPERATIONAL_REPORT_MAX_CHART_CATEGORIES = 100;
 var OPERATIONAL_REPORT_MAX_RECORD_SETS = 8;
 var OPERATIONAL_REPORT_MAX_FIELDS = 8;
 var OPERATIONAL_REPORT_MAX_RECORDS = 25;
@@ -1004,6 +1007,83 @@ function sanitizeOperationalReport(args) {
   }).filter(
     (recordSet) => Boolean(recordSet)
   );
+  const widgets = args.report.widgets?.slice(0, OPERATIONAL_REPORT_MAX_WIDGETS).map((widget, widgetIndex) => {
+    const id = operationalReportText(widget.id, OPERATIONAL_REPORT_MAX_LABEL_LENGTH) ?? String(widgetIndex);
+    const title2 = operationalReportText(
+      widget.title,
+      OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+    );
+    if (!title2) {
+      return void 0;
+    }
+    const seriesEntries = widget.series.slice(0, OPERATIONAL_REPORT_MAX_CHART_SERIES).map((item) => {
+      const key = operationalReportText(
+        item.key,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      );
+      const label = operationalReportText(
+        item.label,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      );
+      if (!key || !label) {
+        return void 0;
+      }
+      const sanitizedSeries = { key, label };
+      const tone = operationalReportTone(item.tone);
+      if (tone) {
+        sanitizedSeries.tone = tone;
+      }
+      return { sanitizedSeries, sourceKey: item.key };
+    }).filter((item) => Boolean(item));
+    if (!seriesEntries.length) {
+      return void 0;
+    }
+    const series = seriesEntries.map((item) => item.sanitizedSeries);
+    const categories = widget.categories.slice(-OPERATIONAL_REPORT_MAX_CHART_CATEGORIES).map((category, categoryIndex) => ({
+      id: operationalReportText(
+        category.id,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      ) ?? `${widgetIndex}:${categoryIndex}`,
+      label: operationalReportText(
+        category.label,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      ) ?? String(categoryIndex + 1),
+      values: Object.fromEntries(
+        seriesEntries.map(({ sanitizedSeries, sourceKey }) => [
+          sanitizedSeries.key,
+          Number.isFinite(category.values[sourceKey]) ? category.values[sourceKey] : 0
+        ])
+      )
+    }));
+    const sanitizedWidget = {
+      categories,
+      id,
+      series,
+      title: title2,
+      type: "bar_chart"
+    };
+    const description = operationalReportText(
+      widget.description,
+      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
+    );
+    if (description) {
+      sanitizedWidget.description = description;
+    }
+    const emptyText = operationalReportText(
+      widget.emptyText,
+      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
+    );
+    if (emptyText) {
+      sanitizedWidget.emptyText = emptyText;
+    }
+    const timeRangeDays = widget.timeRangeDays?.filter(
+      (days) => days === 7 || days === 30 || days === 90
+    );
+    if (timeRangeDays?.length) {
+      sanitizedWidget.timeRangeDays = [...new Set(timeRangeDays)];
+    }
+    return sanitizedWidget;
+  }).filter((widget) => Boolean(widget));
   const sanitized = {
     pluginName: args.pluginName
   };
@@ -1020,6 +1100,9 @@ function sanitizeOperationalReport(args) {
   if (metrics?.length) {
     sanitized.metrics = metrics;
   }
+  if (widgets?.length) {
+    sanitized.widgets = widgets;
+  }
   const title = operationalReportText(
     args.report.title,
     OPERATIONAL_REPORT_MAX_LABEL_LENGTH

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-FWJRXN4F.js → chunk-3S7YYHBI.js}

@@ -1,19 +1,12 @@
 import {
   healthReportSchema
-} from "./chunk-CEA3A3UA.js";
+} from "./chunk-2ZTTXTSZ.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-RGX4V75M.js";
-import {
-  juniorConversationEvents,
-  juniorConversations
-} from "./chunk-TMBRFULF.js";
-import {
-  juniorDestinations
-} from "./chunk-VFUK3X5B.js";
+} from "./chunk-L5XQPJ7T.js";
 import {
   parseSlackThreadId
-} from "./chunk-O3JMSZLI.js";
+} from "./chunk-6Y5L4BOM.js";
 import {
   getClient
 } from "./chunk-6GWA276C.js";
@@ -66,133 +59,6 @@ function buildSentryConversationUrl(conversationId) {
   return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
 }
 
-// src/chat/conversations/sql/privacy.ts
-import { and, asc, eq, getTableColumns, inArray, sql } from "drizzle-orm";
-var MAX_LINEAGE_DEPTH = 32;
-var conversationEventColumns = getTableColumns(juniorConversationEvents);
-function rootVisibilitySnapshotSql(conversationId) {
-  return sql`(
-    with recursive lineage(
-      conversation_id,
-      parent_conversation_id,
-      destination_id,
-      path,
-      depth
-    ) as (
-      select
-        requested.conversation_id,
-        requested.parent_conversation_id,
-        requested.destination_id,
-        array[requested.conversation_id]::text[],
-        1
-      from junior_conversations requested
-      where requested.conversation_id = ${conversationId}
-
-      union all
-
-      select
-        parent.conversation_id,
-        parent.parent_conversation_id,
-        parent.destination_id,
-        lineage.path || parent.conversation_id,
-        lineage.depth + 1
-      from lineage
-      join junior_conversations parent
-        on parent.conversation_id = lineage.parent_conversation_id
-      where lineage.depth < ${MAX_LINEAGE_DEPTH}
-        and not (parent.conversation_id = any(lineage.path))
-    ),
-    root_candidate as (
-      select lineage.conversation_id, lineage.destination_id
-      from lineage
-      where lineage.parent_conversation_id is null
-        and lineage.destination_id is not null
-      limit 1
-    )
-    select jsonb_build_object(
-      'rootConversationId', coalesce(root.conversation_id, ${conversationId}),
-      'visibility', destination.visibility
-    )
-    from (select 1) seed
-    left join root_candidate root on true
-    left join junior_destinations destination
-      on destination.id = root.destination_id
-  )`;
-}
-async function readConversationEventPrivacySnapshot(executor, args) {
-  const rows = await executor.db().select({
-    privacy: rootVisibilitySnapshotSql(args.conversationId),
-    event: {
-      ...conversationEventColumns,
-      // Replacement history is model context, never dashboard report data.
-      // Keep the required replacement field while redacting its contents.
-      payload: sql`case
-          when ${juniorConversationEvents.type} in ('compaction', 'handoff')
-          then jsonb_set(
-            ${juniorConversationEvents.payload},
-            '{replacementHistory}',
-            '[]'::jsonb
-          )
-          else ${juniorConversationEvents.payload}
-        end`
-    }
-  }).from(juniorConversations).leftJoin(
-    juniorConversationEvents,
-    and(
-      eq(juniorConversationEvents.conversationId, args.conversationId),
-      inArray(juniorConversationEvents.type, [...args.eventTypes])
-    )
-  ).where(eq(juniorConversations.conversationId, args.conversationId)).orderBy(asc(juniorConversationEvents.seq));
-  const first = rows[0];
-  if (!first) return void 0;
-  return {
-    ...first.privacy,
-    events: rows.flatMap(({ event }) => event ? [event] : [])
-  };
-}
-async function readLineageRow(executor, conversationId) {
-  const rows = await executor.db().select({
-    parentId: juniorConversations.parentConversationId,
-    destinationId: juniorConversations.destinationId
-  }).from(juniorConversations).where(eq(juniorConversations.conversationId, conversationId));
-  return rows[0];
-}
-async function traceLineage(executor, conversationId) {
-  let currentId = conversationId;
-  const seen = /* @__PURE__ */ new Set();
-  while (!seen.has(currentId) && seen.size < MAX_LINEAGE_DEPTH) {
-    seen.add(currentId);
-    const row = await readLineageRow(executor, currentId);
-    if (!row) return void 0;
-    if (row.parentId) {
-      currentId = row.parentId;
-      continue;
-    }
-    if (!row.destinationId) {
-      return void 0;
-    }
-    return {
-      destinationId: row.destinationId,
-      rootConversationId: currentId
-    };
-  }
-  return void 0;
-}
-async function readCandidateVisibility(executor, candidate) {
-  const destinations = await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, candidate.destinationId)).for("share");
-  return {
-    rootConversationId: candidate.rootConversationId,
-    visibility: destinations[0]?.visibility ?? null
-  };
-}
-async function resolveRootVisibility(executor, conversationId) {
-  const candidate = await traceLineage(executor, conversationId);
-  if (!candidate) {
-    return { rootConversationId: conversationId, visibility: null };
-  }
-  return readCandidateVisibility(executor, candidate);
-}
-
 // src/chat/slack/conversation-context.ts
 function normalizeConversationName(type, channelName) {
   const trimmed = channelName?.trim();
@@ -279,8 +145,6 @@ export {
   readHealthReport,
   GET,
   buildSentryConversationUrl,
-  readConversationEventPrivacySnapshot,
-  resolveRootVisibility,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,

package/dist/{chunk-3SXUV423.js → chunk-3TV7OEHL.js}

@@ -1,6 +1,6 @@
 import {
   createPluginCatalogRuntime
-} from "./chunk-TT6GMXNA.js";
+} from "./chunk-Y3H2DN6F.js";
 
 // src/chat/plugins/catalog-runtime.ts
 var pluginCatalogRuntime = createPluginCatalogRuntime();

package/dist/{chunk-MXW4GL53.js → chunk-3UBQI73J.js}

@@ -14,20 +14,20 @@ import {
   markTurnCompleted,
   mergeArtifactsState,
   updateConversationStats
-} from "./chunk-72OMGPDS.js";
+} from "./chunk-C5XAFTHY.js";
 import {
   createPluginEmbedder,
   createPluginLogger,
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-QY636HZU.js";
+} from "./chunk-2T7TIEXI.js";
 import {
   getStateAdapter
-} from "./chunk-OUHNWH46.js";
+} from "./chunk-GK47NBDE.js";
 import {
   getDb
-} from "./chunk-FENLIFJD.js";
+} from "./chunk-4QU44P7Q.js";
 import {
   getPiMessageRole,
   instructionTextForProjection,
@@ -35,13 +35,13 @@ import {
   isToolResultMessage,
   normalizeToolNameFromResult,
   stripRuntimeTurnContext
-} from "./chunk-JNAVF45E.js";
+} from "./chunk-WNOVRQ67.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-IYKPU7H6.js";
 import {
   parseSlackMessageTs
-} from "./chunk-IVVGFRQQ.js";
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/services/turn-failure-response.ts
 function requireTurnFailureEventId(eventId, eventName) {

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-FENLIFJD.js → chunk-4QU44P7Q.js}

@@ -4,26 +4,67 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-TMBRFULF.js";
+} from "./chunk-JQFJO5WH.js";
 import {
   getChatConfig,
   modelProfileSchema
-} from "./chunk-JNAVF45E.js";
+} from "./chunk-WNOVRQ67.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import {
-  parseDestination,
-  sameDestination
-} from "./chunk-SYAQIR5Z.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-IYKPU7H6.js";
+import {
+  parseSlackChannelReferenceId,
+  parseSlackTeamId
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { and as and2, asc, desc, eq as eq2, isNull, sql as sql2 } from "drizzle-orm";
 
+// src/chat/destination.ts
+import {
+  destinationSchema
+} from "@sentry/junior-plugin-api";
+function createSlackDestination(input) {
+  const channelId = parseSlackChannelReferenceId(input.channelId);
+  const teamId = parseSlackTeamId(input.teamId);
+  if (!channelId || !teamId) {
+    return void 0;
+  }
+  return { platform: "slack", teamId, channelId };
+}
+function parseDestination(value) {
+  const parsed = destinationSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function requireSlackDestination(destination, action) {
+  if (destination?.platform === "slack") {
+    return destination;
+  }
+  throw new Error(`${action} requires a Slack destination`);
+}
+function sameDestination(left, right) {
+  if (left.platform !== right.platform) {
+    return false;
+  }
+  if (left.platform === "local" && right.platform === "local") {
+    return left.conversationId === right.conversationId;
+  }
+  if (left.platform === "slack" && right.platform === "slack") {
+    return left.teamId === right.teamId && left.channelId === right.channelId;
+  }
+  return false;
+}
+function destinationKey(destination) {
+  if (destination.platform === "local") {
+    return destination.conversationId;
+  }
+  return `slack:${destination.teamId}:${destination.channelId}`;
+}
+
 // src/chat/identities/sql.ts
 import { randomUUID } from "crypto";
 import { and, eq, sql } from "drizzle-orm";
@@ -592,7 +633,12 @@ var SqlStore = class {
       actorIdentityObservation,
       conversation.updatedAtMs
     ) : void 0;
-    await this.executor.db().insert(juniorConversations).values({
+    const rootConversationId = conversation.lineage ? sql2`(
+          select parent.root_conversation_id
+          from junior_conversations parent
+          where parent.conversation_id = ${conversation.lineage.parentConversationId}
+        )` : conversation.conversationId;
+    const rows = await this.executor.db().insert(juniorConversations).values({
       conversationId: conversation.conversationId,
       schemaVersion: 1,
       source: conversation.source ?? null,
@@ -615,7 +661,8 @@ var SqlStore = class {
       runId: conversation.execution.runId ?? null,
       lastCheckpointAt: conversation.execution.lastCheckpointAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastCheckpointAtMs),
       lastEnqueuedAt: conversation.execution.lastEnqueuedAtMs === void 0 ? null : dateFromMs2(conversation.execution.lastEnqueuedAtMs),
-      parentConversationId: conversation.lineage?.parentConversationId ?? null
+      parentConversationId: conversation.lineage?.parentConversationId ?? null,
+      rootConversationId
     }).onConflictDoUpdate({
       target: juniorConversations.conversationId,
       set: {
@@ -636,9 +683,15 @@ var SqlStore = class {
         executionStatus: sql2`case when ${incomingExecutionIsFresh} then excluded.execution_status else ${juniorConversations.executionStatus} end`,
         runId: sql2`case when ${incomingExecutionIsFresh} then excluded.run_id else ${juniorConversations.runId} end`,
         lastCheckpointAt: sql2`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_checkpoint_at, ${juniorConversations.lastCheckpointAt}) else ${juniorConversations.lastCheckpointAt} end`,
-        lastEnqueuedAt: sql2`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`
+        lastEnqueuedAt: sql2`case when ${incomingExecutionIsFresh} then coalesce(excluded.last_enqueued_at, ${juniorConversations.lastEnqueuedAt}) else ${juniorConversations.lastEnqueuedAt} end`,
+        rootConversationId: sql2`coalesce(${juniorConversations.rootConversationId}, excluded.root_conversation_id)`
       }
+    }).returning({
+      rootConversationId: juniorConversations.rootConversationId
     });
+    if (!rows[0]?.rootConversationId) {
+      throw new Error("Conversation parent is missing its persisted root");
+    }
   }
   async upsertDestination(destination, nowMs) {
     if (!destination) {
@@ -761,6 +814,7 @@ var historyReplacementEventDataSchema = z2.discriminatedUnion("type", [
     type: z2.literal("handoff"),
     modelProfile: handoffModelProfileSchema,
     modelId: z2.string().min(1),
+    reasoningLevel: z2.string().min(1).optional(),
     triggeringToolCallId: z2.string().min(1).optional(),
     replacementHistory: replacementHistorySchema
   }).strict(),
@@ -1344,6 +1398,11 @@ async function closeDb() {
 }
 
 export {
+  createSlackDestination,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination,
+  destinationKey,
   instructionProvenanceFor,
   contextProvenance,
   instructionActors,

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-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";

package/dist/{chunk-72OMGPDS.js → chunk-C5XAFTHY.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-MU6HHZEN.js";
 import {
   getStateAdapter
-} from "./chunk-OUHNWH46.js";
+} from "./chunk-GK47NBDE.js";
 import {
   contextProvenance,
   createSqlConversationEventStore,
@@ -15,7 +15,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-FENLIFJD.js";
+} from "./chunk-4QU44P7Q.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -28,24 +28,22 @@ import {
   standardModelId,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-JNAVF45E.js";
+} from "./chunk-WNOVRQ67.js";
 import {
   toStoredSlackActor
-} from "./chunk-PLB7MRCQ.js";
+} from "./chunk-C4MZ3GP5.js";
 import {
   getActiveTraceId,
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-ISMWX44P.js";
+} from "./chunk-IYKPU7H6.js";
 import {
   isRecord,
+  parseSlackMessageTs,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-OB42YVAE.js";
-import {
-  parseSlackMessageTs
-} from "./chunk-IVVGFRQQ.js";
+} from "./chunk-42WRQLJ6.js";
 
 // src/chat/conversations/projection.ts
 import { isDeepStrictEqual } from "util";