@sentry/junior 0.57.0 → 0.59.0

package/dist/chunk-I4FDGMFI.js

@@ -0,0 +1,950 @@
+import {
+  getChatConfig,
+  getConnectedStateContext,
+  getStateAdapter
+} from "./chunk-FKEKRBUB.js";
+import {
+  isRecord
+} from "./chunk-H652GMDH.js";
+import {
+  sentry_exports
+} from "./chunk-Z3YD6NHK.js";
+
+// src/handlers/health.ts
+function GET() {
+  return Response.json({
+    status: "ok",
+    service: "junior",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/chat/state/turn-session.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+
+// src/chat/state/session-log.ts
+import { isDeepStrictEqual } from "util";
+import { z } from "zod";
+var AGENT_SESSION_LOG_PREFIX = "junior:agent-session-log";
+var AGENT_SESSION_LOG_SCHEMA_VERSION = 1;
+var INITIAL_SESSION_ID = "session_0";
+var SESSION_ID_PREFIX = "session_";
+var piMessageSchema = z.object({
+  role: z.string()
+}).passthrough().transform((value) => value);
+var piMessageEntrySchema = z.object({
+  schemaVersion: z.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z.literal("pi_message"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  message: piMessageSchema
+});
+var projectionResetEntrySchema = z.object({
+  schemaVersion: z.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z.literal("projection_reset"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  messages: z.array(piMessageSchema)
+});
+var mcpProviderConnectedEntrySchema = z.object({
+  schemaVersion: z.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z.literal("mcp_provider_connected"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  provider: z.string().min(1)
+});
+var authorizationKindSchema = z.union([
+  z.literal("plugin"),
+  z.literal("mcp")
+]);
+var authorizationRequestedEntrySchema = z.object({
+  schemaVersion: z.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z.literal("authorization_requested"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z.string().min(1),
+  requesterId: z.string().min(1),
+  authorizationId: z.string().min(1),
+  delivery: z.union([
+    z.literal("private_link_sent"),
+    z.literal("private_link_reused")
+  ])
+});
+var authorizationCompletedEntrySchema = z.object({
+  schemaVersion: z.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z.literal("authorization_completed"),
+  sessionId: z.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z.string().min(1),
+  requesterId: z.string().min(1),
+  authorizationId: z.string().min(1)
+});
+var sessionLogEntrySchema = z.discriminatedUnion("type", [
+  piMessageEntrySchema,
+  projectionResetEntrySchema,
+  mcpProviderConnectedEntrySchema,
+  authorizationRequestedEntrySchema,
+  authorizationCompletedEntrySchema
+]);
+function key(scope) {
+  const prefix = getChatConfig().state.keyPrefix;
+  return [
+    ...prefix ? [prefix] : [],
+    AGENT_SESSION_LOG_PREFIX,
+    scope.conversationId
+  ].join(":");
+}
+function rawKey(scope) {
+  return [AGENT_SESSION_LOG_PREFIX, scope.conversationId].join(":");
+}
+function normalizeMessageCount(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function countMatchingPrefix(left, right) {
+  const limit = Math.min(left.length, right.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (!isDeepStrictEqual(left[index], right[index])) {
+      return index;
+    }
+  }
+  return limit;
+}
+function entrySessionId(entry) {
+  return entry.sessionId ?? INITIAL_SESSION_ID;
+}
+function latestProjectionResetIndex(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    if (entries[index]?.type === "projection_reset") {
+      return index;
+    }
+  }
+  return -1;
+}
+function currentSessionId(entries) {
+  const resetIndex = latestProjectionResetIndex(entries);
+  if (resetIndex < 0) {
+    return INITIAL_SESSION_ID;
+  }
+  return entrySessionId(entries[resetIndex]);
+}
+function nextSessionId(entries) {
+  const resetCount = entries.filter(
+    (entry) => entry.type === "projection_reset"
+  ).length;
+  return `${SESSION_ID_PREFIX}${resetCount + 1}`;
+}
+function projectionEntries(entries, sessionId) {
+  if (sessionId) {
+    const sessionEntries = [];
+    let started = false;
+    for (const entry of entries) {
+      const entryId = entrySessionId(entry);
+      if (!started) {
+        if (entryId !== sessionId) {
+          continue;
+        }
+        started = true;
+      } else if (entry.type === "projection_reset" && entryId !== sessionId) {
+        break;
+      }
+      if (entryId === sessionId) {
+        sessionEntries.push(entry);
+      }
+    }
+    return sessionEntries;
+  }
+  const resetIndex = latestProjectionResetIndex(entries);
+  const startIndex = resetIndex < 0 ? 0 : resetIndex;
+  const currentId = resetIndex < 0 ? INITIAL_SESSION_ID : entrySessionId(entries[resetIndex]);
+  return entries.slice(startIndex).filter((entry) => entrySessionId(entry) === currentId);
+}
+function piEntry(message, sessionId) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "pi_message",
+    sessionId,
+    message
+  };
+}
+function resetEntry(messages, sessionId) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "projection_reset",
+    sessionId,
+    messages
+  };
+}
+function mcpProviderConnectedEntry(provider, sessionId) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "mcp_provider_connected",
+    sessionId,
+    provider
+  };
+}
+function authorizationObservationMessage(entry) {
+  const label = entry.kind === "mcp" ? "MCP authorization" : "Authorization";
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `${label} completed for provider "${entry.provider}". Continue the blocked request and retry the provider operation if needed.`
+      }
+    ],
+    timestamp: entry.createdAtMs
+  };
+}
+function authorizationRequestedEntry(args) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "authorization_requested",
+    sessionId: args.sessionId,
+    createdAtMs: args.createdAtMs,
+    kind: args.kind,
+    provider: args.provider,
+    requesterId: args.requesterId,
+    authorizationId: args.authorizationId,
+    delivery: args.delivery
+  };
+}
+function authorizationCompletedEntry(args) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "authorization_completed",
+    sessionId: args.sessionId,
+    createdAtMs: args.createdAtMs,
+    kind: args.kind,
+    provider: args.provider,
+    requesterId: args.requesterId,
+    authorizationId: args.authorizationId
+  };
+}
+function decode(value) {
+  if (typeof value === "string") {
+    return decode(JSON.parse(value));
+  }
+  const parsed = sessionLogEntrySchema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  return piEntry(piMessageSchema.parse(value), INITIAL_SESSION_ID);
+}
+function project(entries, sessionId) {
+  let messages = [];
+  for (const entry of projectionEntries(entries, sessionId)) {
+    if (entry.type === "pi_message") {
+      messages.push(entry.message);
+      continue;
+    }
+    if (entry.type === "authorization_completed") {
+      messages.push(authorizationObservationMessage(entry));
+      continue;
+    }
+    if (entry.type === "mcp_provider_connected" || entry.type === "authorization_requested") {
+      continue;
+    }
+    messages = [...entry.messages];
+  }
+  return messages;
+}
+function connectedMcpProviders(entries, sessionId) {
+  const providers = /* @__PURE__ */ new Set();
+  for (const entry of projectionEntries(entries, sessionId)) {
+    if (entry.type === "mcp_provider_connected") {
+      providers.add(entry.provider);
+    }
+  }
+  return [...providers].sort((left, right) => left.localeCompare(right));
+}
+function commitEntries(existingMessages, nextMessages, sessionId, entries) {
+  const matchingPrefix = countMatchingPrefix(existingMessages, nextMessages);
+  if (matchingPrefix === existingMessages.length) {
+    return nextMessages.slice(matchingPrefix).map((message) => piEntry(message, sessionId));
+  }
+  return [resetEntry(nextMessages, nextSessionId(entries))];
+}
+function redisStore(redisStateAdapter) {
+  const client = redisStateAdapter.getClient();
+  return {
+    async append({ entries, scope, ttlMs }) {
+      const listKey = key(scope);
+      if (entries.length > 0) {
+        await client.rPush(
+          listKey,
+          entries.map((entry) => JSON.stringify(entry))
+        );
+      }
+      await client.pExpire(listKey, Math.max(1, ttlMs));
+    },
+    async read(scope) {
+      const values = await client.lRange(key(scope), 0, -1);
+      return values.map(decode);
+    }
+  };
+}
+function stateStore() {
+  const stateAdapter = getStateAdapter();
+  return {
+    async append({ entries, scope, ttlMs }) {
+      const listKey = rawKey(scope);
+      for (const entry of entries) {
+        await stateAdapter.appendToList(listKey, entry, {
+          ttlMs: Math.max(1, ttlMs)
+        });
+      }
+    },
+    async read(scope) {
+      const values = await stateAdapter.getList(rawKey(scope));
+      return values.map(decode);
+    }
+  };
+}
+async function defaultStore() {
+  const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
+  if (redisStateAdapter) {
+    return redisStore(redisStateAdapter);
+  }
+  await stateAdapter.connect();
+  return stateStore();
+}
+async function loadEntries(args) {
+  const store = args.store ?? await defaultStore();
+  return await store.read(args);
+}
+async function loadMessages(args) {
+  const messageCount = normalizeMessageCount(args.messageCount);
+  if (messageCount === 0) {
+    return [];
+  }
+  const store = args.store ?? await defaultStore();
+  const messages = project(await store.read(args), args.sessionId);
+  return messages.length >= messageCount ? messages.slice(0, messageCount) : void 0;
+}
+async function loadProjection(args) {
+  const store = args.store ?? await defaultStore();
+  return project(await store.read(args), args.sessionId);
+}
+async function loadConnectedMcpProviders(args) {
+  return connectedMcpProviders(await loadEntries(args));
+}
+async function recordMcpProviderConnected(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const sessionId = currentSessionId(entries);
+  if (connectedMcpProviders(entries).includes(args.provider)) {
+    return;
+  }
+  await store.append({
+    scope: args,
+    entries: [mcpProviderConnectedEntry(args.provider, sessionId)],
+    ttlMs: args.ttlMs
+  });
+}
+async function recordAuthorizationRequested(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const sessionId = currentSessionId(entries);
+  if (projectionEntries(entries).some(
+    (entry) => entry.type === "authorization_requested" && entry.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await store.append({
+    scope: args,
+    entries: [
+      authorizationRequestedEntry({
+        createdAtMs: Date.now(),
+        kind: args.kind,
+        sessionId,
+        provider: args.provider,
+        requesterId: args.requesterId,
+        authorizationId: args.authorizationId,
+        delivery: args.delivery
+      })
+    ],
+    ttlMs: args.ttlMs
+  });
+}
+async function recordAuthorizationCompleted(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const sessionId = currentSessionId(entries);
+  if (projectionEntries(entries).some(
+    (entry) => entry.type === "authorization_completed" && entry.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await store.append({
+    scope: args,
+    entries: [
+      authorizationCompletedEntry({
+        createdAtMs: Date.now(),
+        kind: args.kind,
+        sessionId,
+        provider: args.provider,
+        requesterId: args.requesterId,
+        authorizationId: args.authorizationId
+      })
+    ],
+    ttlMs: args.ttlMs
+  });
+}
+async function commitMessages(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const existingMessages = project(entries);
+  const currentId = currentSessionId(entries);
+  const nextEntries = commitEntries(
+    existingMessages,
+    args.messages,
+    currentId,
+    entries
+  );
+  await store.append({
+    scope: args,
+    entries: nextEntries,
+    ttlMs: args.ttlMs
+  });
+  return {
+    sessionId: nextEntries.find((entry) => entry.type === "projection_reset")?.sessionId ?? currentId
+  };
+}
+
+// src/chat/state/turn-session.ts
+var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX}:index`;
+var AGENT_TURN_SESSION_INDEX_MAX_LENGTH = 5e3;
+var AGENT_TURN_SESSION_TTL_MS = THREAD_STATE_TTL_MS;
+function agentTurnSessionKey(conversationId, sessionId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+}
+function agentTurnSessionConversationIndexKey(conversationId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
+}
+function toFiniteNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function parseAgentTurnUsage(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const usage = {};
+  for (const field of [
+    "inputTokens",
+    "outputTokens",
+    "cachedInputTokens",
+    "cacheCreationTokens",
+    "totalTokens"
+  ]) {
+    const count = toFiniteNonNegativeNumber(value[field]);
+    if (count !== void 0) {
+      usage[field] = count;
+    }
+  }
+  return Object.keys(usage).length > 0 ? usage : void 0;
+}
+function parseAgentTurnRequester(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const requester = {};
+  for (const field of [
+    "email",
+    "fullName",
+    "slackUserId",
+    "slackUserName"
+  ]) {
+    if (typeof value[field] === "string" && value[field].trim()) {
+      requester[field] = value[field].trim();
+    }
+  }
+  return Object.keys(requester).length > 0 ? requester : void 0;
+}
+function parseStoredRecord(value) {
+  if (isRecord(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseAgentTurnSessionStatus(parsed) {
+  const status = parsed.state;
+  if (status === "running" || status === "awaiting_resume" || status === "completed" || status === "failed" || status === "abandoned") {
+    return status;
+  }
+  return void 0;
+}
+function parseAgentTurnSessionFields(parsed) {
+  const status = parseAgentTurnSessionStatus(parsed);
+  if (!status) {
+    return void 0;
+  }
+  const channelName = typeof parsed.channelName === "string" && parsed.channelName.trim() ? parsed.channelName.trim() : void 0;
+  const conversationTitle = typeof parsed.conversationTitle === "string" && parsed.conversationTitle.trim() ? parsed.conversationTitle.trim() : void 0;
+  const conversationId = parsed.conversationId;
+  const sessionId = parsed.sessionId;
+  const sliceId = toFiniteNonNegativeNumber(parsed.sliceId);
+  const version = toFiniteNonNegativeNumber(parsed.version);
+  const updatedAtMs = toFiniteNonNegativeNumber(parsed.updatedAtMs);
+  const cumulativeDurationMs = toFiniteNonNegativeNumber(
+    parsed.cumulativeDurationMs
+  );
+  const cumulativeUsage = parseAgentTurnUsage(parsed.cumulativeUsage);
+  const lastProgressAtMs = toFiniteNonNegativeNumber(parsed.lastProgressAtMs);
+  const logSessionId = typeof parsed.logSessionId === "string" ? parsed.logSessionId : void 0;
+  const requester = parseAgentTurnRequester(parsed.requester);
+  const startedAtMs = toFiniteNonNegativeNumber(parsed.startedAtMs);
+  if (typeof conversationId !== "string" || typeof sessionId !== "string" || sliceId === void 0 || version === void 0 || updatedAtMs === void 0) {
+    return void 0;
+  }
+  return {
+    version,
+    ...channelName ? { channelName } : {},
+    ...conversationTitle ? { conversationTitle } : {},
+    conversationId,
+    sessionId,
+    sliceId,
+    state: status,
+    startedAtMs: startedAtMs ?? updatedAtMs,
+    lastProgressAtMs: lastProgressAtMs ?? updatedAtMs,
+    updatedAtMs,
+    ...logSessionId ? { logSessionId } : {},
+    ...cumulativeDurationMs !== void 0 ? { cumulativeDurationMs } : {},
+    ...cumulativeUsage ? { cumulativeUsage } : {},
+    ...requester ? { requester } : {},
+    ...Array.isArray(parsed.loadedSkillNames) ? {
+      loadedSkillNames: parsed.loadedSkillNames.filter(
+        (value) => typeof value === "string"
+      )
+    } : {},
+    ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
+    ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
+    ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {},
+    ...typeof parsed.traceId === "string" ? { traceId: parsed.traceId } : {}
+  };
+}
+function parseAgentTurnSessionRecord(value) {
+  const parsed = parseStoredRecord(value);
+  if (!parsed) {
+    return void 0;
+  }
+  const fields = parseAgentTurnSessionFields(parsed);
+  const committedMessageCount = toFiniteNonNegativeNumber(
+    parsed.committedMessageCount
+  );
+  if (!fields || committedMessageCount === void 0) {
+    return void 0;
+  }
+  return {
+    ...fields,
+    committedMessageCount
+  };
+}
+function parseAgentTurnSessionSummary(value) {
+  const stored = parseStoredRecord(value);
+  if (!stored) {
+    return void 0;
+  }
+  const parsed = parseAgentTurnSessionFields(stored);
+  if (!parsed) {
+    return void 0;
+  }
+  const {
+    errorMessage: _errorMessage,
+    logSessionId: _logSessionId,
+    ...summary
+  } = parsed;
+  return summary;
+}
+async function appendAgentTurnSessionSummary(summary, ttlMs) {
+  const stateAdapter = getStateAdapter();
+  await Promise.all([
+    stateAdapter.appendToList(AGENT_TURN_SESSION_INDEX_KEY, summary, {
+      maxLength: AGENT_TURN_SESSION_INDEX_MAX_LENGTH,
+      ttlMs
+    }),
+    stateAdapter.appendToList(
+      agentTurnSessionConversationIndexKey(summary.conversationId),
+      summary,
+      { ttlMs }
+    )
+  ]);
+}
+function materializePiMessages(committedMessageCount, includeProjectionTail, sessionMessages, sessionProjection) {
+  if (committedMessageCount === 0) {
+    return sessionProjection;
+  }
+  if (includeProjectionTail && sessionProjection.length >= committedMessageCount) {
+    return sessionProjection;
+  }
+  if (sessionMessages) {
+    return sessionMessages;
+  }
+  if (sessionProjection.length >= committedMessageCount) {
+    return sessionProjection.slice(0, committedMessageCount);
+  }
+  return void 0;
+}
+function materializeAgentTurnSessionRecord(stored, piMessages) {
+  return {
+    version: stored.version,
+    ...stored.channelName ? { channelName: stored.channelName } : {},
+    ...stored.conversationTitle ? { conversationTitle: stored.conversationTitle } : {},
+    conversationId: stored.conversationId,
+    sessionId: stored.sessionId,
+    sliceId: stored.sliceId,
+    state: stored.state,
+    startedAtMs: stored.startedAtMs,
+    lastProgressAtMs: stored.lastProgressAtMs,
+    updatedAtMs: stored.updatedAtMs,
+    piMessages,
+    ...stored.cumulativeDurationMs !== void 0 ? { cumulativeDurationMs: stored.cumulativeDurationMs } : {},
+    ...stored.cumulativeUsage ? { cumulativeUsage: stored.cumulativeUsage } : {},
+    ...stored.resumeReason ? { resumeReason: stored.resumeReason } : {},
+    ...stored.errorMessage ? { errorMessage: stored.errorMessage } : {},
+    ...stored.loadedSkillNames ? { loadedSkillNames: stored.loadedSkillNames } : {},
+    ...stored.requester ? { requester: stored.requester } : {},
+    ...stored.resumedFromSliceId !== void 0 ? { resumedFromSliceId: stored.resumedFromSliceId } : {},
+    ...stored.traceId ? { traceId: stored.traceId } : {}
+  };
+}
+async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const value = await stateAdapter.get(
+    agentTurnSessionKey(conversationId, sessionId)
+  );
+  return parseAgentTurnSessionRecord(value);
+}
+async function getAgentTurnSessionRecord(conversationId, sessionId) {
+  const parsed = await getStoredAgentTurnSessionRecord(
+    conversationId,
+    sessionId
+  );
+  if (!parsed) {
+    return void 0;
+  }
+  const sessionMessages = await loadMessages({
+    conversationId,
+    messageCount: parsed.committedMessageCount,
+    ...parsed.logSessionId ? { sessionId: parsed.logSessionId } : {}
+  });
+  const sessionProjection = await loadProjection({
+    conversationId,
+    ...parsed.logSessionId ? { sessionId: parsed.logSessionId } : {}
+  });
+  const piMessages = materializePiMessages(
+    parsed.committedMessageCount,
+    parsed.state === "running" || parsed.state === "awaiting_resume",
+    sessionMessages,
+    sessionProjection
+  );
+  if (!piMessages) {
+    return void 0;
+  }
+  return materializeAgentTurnSessionRecord(parsed, piMessages);
+}
+function buildStoredRecord(args) {
+  const nowMs = Date.now();
+  return {
+    version: (args.previousVersion ?? 0) + 1,
+    ...args.channelName ? { channelName: args.channelName } : {},
+    ...args.conversationTitle ? { conversationTitle: args.conversationTitle } : {},
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: args.state,
+    startedAtMs: args.startedAtMs ?? nowMs,
+    lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+    updatedAtMs: nowMs,
+    committedMessageCount: args.committedMessageCount,
+    ...args.logSessionId ? { logSessionId: args.logSessionId } : {},
+    ...typeof args.cumulativeDurationMs === "number" && Number.isFinite(args.cumulativeDurationMs) ? {
+      cumulativeDurationMs: Math.max(
+        0,
+        Math.floor(args.cumulativeDurationMs)
+      )
+    } : {},
+    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
+    ...args.requester ? { requester: args.requester } : {},
+    ...Array.isArray(args.loadedSkillNames) ? {
+      loadedSkillNames: args.loadedSkillNames.filter(
+        (value) => typeof value === "string"
+      )
+    } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+    ...args.traceId ? { traceId: args.traceId } : {}
+  };
+}
+async function setStoredRecord(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  await stateAdapter.set(
+    agentTurnSessionKey(args.record.conversationId, args.record.sessionId),
+    args.record,
+    args.ttlMs
+  );
+  const {
+    committedMessageCount: _committedMessageCount,
+    errorMessage: _errorMessage,
+    logSessionId: _logSessionId,
+    ...summary
+  } = args.record;
+  await appendAgentTurnSessionSummary(summary, args.ttlMs);
+  return materializeAgentTurnSessionRecord(args.record, [...args.piMessages]);
+}
+async function updateAgentTurnSessionState(args) {
+  const parsed = await getStoredAgentTurnSessionRecord(
+    args.existing.conversationId,
+    args.existing.sessionId
+  );
+  if (!parsed || parsed.version !== args.existing.version) {
+    return void 0;
+  }
+  return await setStoredRecord({
+    piMessages: args.existing.piMessages,
+    ttlMs: AGENT_TURN_SESSION_TTL_MS,
+    record: buildStoredRecord({
+      conversationId: args.existing.conversationId,
+      sessionId: args.existing.sessionId,
+      sliceId: args.existing.sliceId,
+      state: args.state,
+      committedMessageCount: parsed.committedMessageCount,
+      ...parsed.channelName ? { channelName: parsed.channelName } : {},
+      ...parsed.conversationTitle ? { conversationTitle: parsed.conversationTitle } : {},
+      startedAtMs: parsed.startedAtMs,
+      lastProgressAtMs: parsed.lastProgressAtMs,
+      previousVersion: parsed.version,
+      ...parsed.logSessionId ? { logSessionId: parsed.logSessionId } : {},
+      ...args.existing.cumulativeDurationMs !== void 0 ? { cumulativeDurationMs: args.existing.cumulativeDurationMs } : {},
+      ...args.existing.cumulativeUsage ? { cumulativeUsage: args.existing.cumulativeUsage } : {},
+      ...args.existing.loadedSkillNames ? { loadedSkillNames: args.existing.loadedSkillNames } : {},
+      ...args.existing.requester ? { requester: args.existing.requester } : {},
+      ...args.existing.resumeReason ? { resumeReason: args.existing.resumeReason } : {},
+      ...args.existing.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.existing.resumedFromSliceId } : {},
+      ...args.existing.traceId ? { traceId: args.existing.traceId } : {},
+      ...args.errorMessage ?? args.existing.errorMessage ? { errorMessage: args.errorMessage ?? args.existing.errorMessage } : {}
+    })
+  });
+}
+async function upsertAgentTurnSessionRecord(args) {
+  const existingRecord = await getStoredAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  const commit = await commitMessages({
+    conversationId: args.conversationId,
+    messages: args.piMessages,
+    ttlMs
+  });
+  return await setStoredRecord({
+    piMessages: args.piMessages,
+    ttlMs,
+    record: buildStoredRecord({
+      ...args.channelName ?? existingRecord?.channelName ? { channelName: args.channelName ?? existingRecord?.channelName } : {},
+      ...args.conversationTitle ?? existingRecord?.conversationTitle ? {
+        conversationTitle: args.conversationTitle ?? existingRecord?.conversationTitle
+      } : {},
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: args.state,
+      ...existingRecord?.startedAtMs !== void 0 ? { startedAtMs: existingRecord.startedAtMs } : {},
+      ...args.lastProgressAtMs !== void 0 ? { lastProgressAtMs: args.lastProgressAtMs } : {},
+      committedMessageCount: args.piMessages.length,
+      logSessionId: commit.sessionId,
+      previousVersion: existingRecord?.version,
+      ...args.cumulativeDurationMs !== void 0 ? { cumulativeDurationMs: args.cumulativeDurationMs } : {},
+      ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      ...args.requester ?? existingRecord?.requester ? { requester: args.requester ?? existingRecord?.requester } : {},
+      ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+      ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+      ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+      ...args.traceId ?? existingRecord?.traceId ? { traceId: args.traceId ?? existingRecord?.traceId } : {}
+    })
+  });
+}
+async function recordAgentTurnSessionSummary(args) {
+  const existing = await getStoredAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  const nowMs = Date.now();
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  await appendAgentTurnSessionSummary(
+    {
+      version: existing?.version ?? 0,
+      ...args.channelName ?? existing?.channelName ? { channelName: args.channelName ?? existing?.channelName } : {},
+      ...args.conversationTitle ?? existing?.conversationTitle ? {
+        conversationTitle: args.conversationTitle ?? existing?.conversationTitle
+      } : {},
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      startedAtMs: existing?.startedAtMs ?? args.startedAtMs ?? nowMs,
+      lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+      state: args.state,
+      updatedAtMs: nowMs,
+      ...typeof args.cumulativeDurationMs === "number" && Number.isFinite(args.cumulativeDurationMs) ? {
+        cumulativeDurationMs: Math.max(
+          0,
+          Math.floor(args.cumulativeDurationMs)
+        )
+      } : existing?.cumulativeDurationMs !== void 0 ? { cumulativeDurationMs: existing.cumulativeDurationMs } : {},
+      ...args.cumulativeUsage ?? existing?.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage ?? existing?.cumulativeUsage } : {},
+      ...args.requester ?? existing?.requester ? { requester: args.requester ?? existing?.requester } : {},
+      ...Array.isArray(args.loadedSkillNames) ? {
+        loadedSkillNames: args.loadedSkillNames.filter(
+          (value) => typeof value === "string"
+        )
+      } : existing?.loadedSkillNames ? { loadedSkillNames: existing.loadedSkillNames } : {},
+      ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+      ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
+    },
+    ttlMs
+  );
+}
+async function readAgentTurnSessionSummariesFromIndex(key2) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const values = await stateAdapter.getList(key2);
+  const summaries = /* @__PURE__ */ new Map();
+  for (const value of [...values].reverse()) {
+    const summary = parseAgentTurnSessionSummary(value);
+    if (!summary) {
+      continue;
+    }
+    const key3 = `${summary.conversationId}:${summary.sessionId}`;
+    if (!summaries.has(key3)) {
+      summaries.set(key3, summary);
+    }
+  }
+  return [...summaries.values()].sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
+}
+async function listAgentTurnSessionSummaries(limit = 50) {
+  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).slice(0, Math.max(0, Math.floor(limit)));
+}
+async function listAgentTurnSessionSummariesForConversation(conversationId) {
+  const summaries = await readAgentTurnSessionSummariesFromIndex(
+    agentTurnSessionConversationIndexKey(conversationId)
+  );
+  if (summaries.length > 0) {
+    return summaries;
+  }
+  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).filter((summary) => summary.conversationId === conversationId);
+}
+async function abandonAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "abandoned",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
+}
+async function failAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "failed",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
+}
+
+// src/chat/sentry-links.ts
+function getSentryOrgSlug() {
+  const slug = process.env.SENTRY_ORG_SLUG?.trim();
+  return slug || void 0;
+}
+function isSentrySaasDsnHost(host) {
+  return host === "sentry.io" || host.endsWith(".sentry.io");
+}
+function buildSentryWebBaseUrl(dsn) {
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return "https://sentry.io";
+  }
+  const port = dsn.port ? `:${dsn.port}` : "";
+  const path = dsn.path ? `/${dsn.path}` : "";
+  return `${dsn.protocol}://${dsn.host}${port}${path}`;
+}
+function buildSentryConversationUrl(conversationId) {
+  const client = sentry_exports.getClient();
+  const dsn = client?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedId = encodeURIComponent(conversationId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path = `explore/conversations/${encodedId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+function buildSentryTraceUrl(traceId) {
+  const client = sentry_exports.getClient();
+  const dsn = client?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedTraceId = encodeURIComponent(traceId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path = `performance/trace/${encodedTraceId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+
+export {
+  GET,
+  loadProjection,
+  loadConnectedMcpProviders,
+  recordMcpProviderConnected,
+  recordAuthorizationRequested,
+  recordAuthorizationCompleted,
+  commitMessages,
+  getAgentTurnSessionRecord,
+  upsertAgentTurnSessionRecord,
+  recordAgentTurnSessionSummary,
+  listAgentTurnSessionSummaries,
+  listAgentTurnSessionSummariesForConversation,
+  abandonAgentTurnSessionRecord,
+  failAgentTurnSessionRecord,
+  buildSentryConversationUrl,
+  buildSentryTraceUrl
+};