@sentry/junior 0.88.0 → 0.90.0

package/dist/chunk-GCWD2VHP.js

@@ -0,0 +1,1216 @@
+import {
+  getConnectedStateContext,
+  getStateAdapter
+} from "./chunk-RS6ANWVT.js";
+import {
+  getConversationStore
+} from "./chunk-2S7M37HY.js";
+import {
+  getChatConfig
+} from "./chunk-HXL2ZV74.js";
+import {
+  parseDestination
+} from "./chunk-GHGPTPBL.js";
+import {
+  logWarn,
+  parseRequester,
+  storedSlackRequesterSchema,
+  toStoredSlackRequester
+} from "./chunk-ZUK7BL63.js";
+import {
+  isRecord
+} from "./chunk-OB42YVAE.js";
+
+// src/chat/state/session-log.ts
+import { isDeepStrictEqual } from "util";
+import { z as z2 } from "zod";
+
+// src/chat/pi/messages.ts
+import { z } from "zod";
+var piMessageSchema = z.object({
+  role: z.string()
+}).passthrough().transform((value) => value);
+var piContentMessageSchema = z.object({
+  content: z.array(z.unknown()),
+  role: z.string().min(1)
+}).passthrough().transform((value) => value);
+
+// src/chat/state/session-log.ts
+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 STATE_STORE_LOCK_TTL_MS = 5e3;
+var piMessageEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("pi_message"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  message: piMessageSchema,
+  requester: storedSlackRequesterSchema.optional()
+});
+var projectionResetEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("projection_reset"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  messages: z2.array(piMessageSchema),
+  requester: storedSlackRequesterSchema.optional()
+});
+var requesterRecordedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("requester_recorded"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  requester: storedSlackRequesterSchema
+});
+var mcpProviderConnectedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("mcp_provider_connected"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  provider: z2.string().min(1)
+});
+var authorizationKindSchema = z2.union([
+  z2.literal("plugin"),
+  z2.literal("mcp")
+]);
+var authorizationRequestedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("authorization_requested"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z2.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z2.string().min(1),
+  requesterId: z2.string().min(1),
+  authorizationId: z2.string().min(1),
+  delivery: z2.union([
+    z2.literal("private_link_sent"),
+    z2.literal("private_link_reused")
+  ])
+});
+var authorizationCompletedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("authorization_completed"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z2.number().int().nonnegative(),
+  kind: authorizationKindSchema,
+  provider: z2.string().min(1),
+  requesterId: z2.string().min(1),
+  authorizationId: z2.string().min(1)
+});
+var transcriptRefSchema = z2.object({
+  type: z2.literal("advisor_session"),
+  parentConversationId: z2.string().min(1),
+  key: z2.string().min(1)
+});
+var toolExecutionStartedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("tool_execution_started"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  createdAtMs: z2.number().int().nonnegative(),
+  toolCallId: z2.string().min(1),
+  toolName: z2.string().min(1),
+  args: z2.unknown().optional()
+});
+var subagentStartedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("subagent_started"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z2.string().min(1),
+  subagentKind: z2.string().min(1),
+  parentToolCallId: z2.string().min(1).optional(),
+  parentConversationId: z2.string().min(1),
+  parentSessionId: z2.string().min(1).optional(),
+  transcriptRef: transcriptRefSchema,
+  historyMode: z2.literal("shared"),
+  createdAtMs: z2.number().int().nonnegative()
+});
+var subagentEndedEntrySchema = z2.object({
+  schemaVersion: z2.literal(AGENT_SESSION_LOG_SCHEMA_VERSION),
+  type: z2.literal("subagent_ended"),
+  sessionId: z2.string().min(1).default(INITIAL_SESSION_ID),
+  subagentInvocationId: z2.string().min(1),
+  outcome: z2.union([
+    z2.literal("success"),
+    z2.literal("error"),
+    z2.literal("aborted")
+  ]),
+  errorCode: z2.string().min(1).optional(),
+  transcriptEndMessageIndex: z2.number().int().nonnegative().optional(),
+  transcriptStartMessageIndex: z2.number().int().nonnegative().optional(),
+  createdAtMs: z2.number().int().nonnegative()
+});
+var sessionLogEntrySchema = z2.discriminatedUnion("type", [
+  piMessageEntrySchema,
+  projectionResetEntrySchema,
+  requesterRecordedEntrySchema,
+  mcpProviderConnectedEntrySchema,
+  authorizationRequestedEntrySchema,
+  authorizationCompletedEntrySchema,
+  toolExecutionStartedEntrySchema,
+  subagentStartedEntrySchema,
+  subagentEndedEntrySchema
+]);
+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 isActivityEntry(entry) {
+  return entry.type === "tool_execution_started" || entry.type === "subagent_started" || entry.type === "subagent_ended";
+}
+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 findLastIndex(values, predicate) {
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    if (predicate(values[index])) return index;
+  }
+  return -1;
+}
+function piEntry(message, sessionId, requester) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "pi_message",
+    sessionId,
+    message,
+    ...requester ? { requester } : {}
+  };
+}
+function resetEntry(messages, sessionId, requester) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "projection_reset",
+    sessionId,
+    messages,
+    ...requester ? { requester } : {}
+  };
+}
+function requesterRecordedEntry(requester, sessionId) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "requester_recorded",
+    sessionId,
+    requester
+  };
+}
+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 toolExecutionStartedEntry(args) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "tool_execution_started",
+    sessionId: args.sessionId,
+    createdAtMs: args.createdAtMs,
+    toolCallId: args.toolCallId,
+    toolName: args.toolName,
+    ...args.args !== void 0 ? { args: args.args } : {}
+  };
+}
+function subagentStartedEntry(args) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "subagent_started",
+    sessionId: args.sessionId,
+    subagentInvocationId: args.subagentInvocationId,
+    subagentKind: args.subagentKind,
+    ...args.parentToolCallId ? { parentToolCallId: args.parentToolCallId } : {},
+    parentConversationId: args.parentConversationId,
+    ...args.parentSessionId ? { parentSessionId: args.parentSessionId } : {},
+    transcriptRef: args.transcriptRef,
+    historyMode: args.historyMode,
+    createdAtMs: args.createdAtMs
+  };
+}
+function subagentEndedEntry(args) {
+  return {
+    schemaVersion: AGENT_SESSION_LOG_SCHEMA_VERSION,
+    type: "subagent_ended",
+    sessionId: args.sessionId,
+    subagentInvocationId: args.subagentInvocationId,
+    outcome: args.outcome,
+    ...args.errorCode ? { errorCode: args.errorCode } : {},
+    ...args.transcriptEndMessageIndex !== void 0 ? { transcriptEndMessageIndex: args.transcriptEndMessageIndex } : {},
+    ...args.transcriptStartMessageIndex !== void 0 ? { transcriptStartMessageIndex: args.transcriptStartMessageIndex } : {},
+    createdAtMs: args.createdAtMs
+  };
+}
+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 = [];
+  let requester;
+  for (const entry of projectionEntries(entries, sessionId)) {
+    if (entry.type === "pi_message") {
+      messages.push(entry.message);
+      if (entry.message.role === "user" && entry.requester) {
+        requester = entry.requester;
+      }
+      continue;
+    }
+    if (entry.type === "requester_recorded") {
+      requester = entry.requester;
+      continue;
+    }
+    if (entry.type === "authorization_completed") {
+      messages.push(authorizationObservationMessage(entry));
+      continue;
+    }
+    if (entry.type === "projection_reset") {
+      messages = [...entry.messages];
+      if (entry.requester) {
+        requester = entry.requester;
+      }
+      continue;
+    }
+  }
+  return { messages, requester };
+}
+function projectMessages(entries, sessionId) {
+  return project(entries, sessionId).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, existingRequester, requester) {
+  const matchingPrefix = countMatchingPrefix(existingMessages, nextMessages);
+  if (matchingPrefix === existingMessages.length) {
+    const newMessages = nextMessages.slice(matchingPrefix);
+    if (newMessages.length === 0 && requester && !isDeepStrictEqual(existingRequester, requester)) {
+      return {
+        entries: [requesterRecordedEntry(requester, sessionId)],
+        sessionId
+      };
+    }
+    const requesterIndex = requester ? findLastIndex(newMessages, (m) => m.role === "user") : -1;
+    return {
+      entries: newMessages.map(
+        (message, index) => piEntry(
+          message,
+          sessionId,
+          index === requesterIndex ? requester : void 0
+        )
+      ),
+      sessionId
+    };
+  }
+  const resetSessionId = nextSessionId(entries);
+  return {
+    entries: [
+      resetEntry(nextMessages, resetSessionId, requester ?? existingRequester)
+    ],
+    sessionId: resetSessionId
+  };
+}
+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);
+      const lock = await stateAdapter.acquireLock(
+        `${listKey}:commit`,
+        STATE_STORE_LOCK_TTL_MS
+      );
+      if (!lock) {
+        throw new Error("Could not acquire session log commit lock");
+      }
+      try {
+        const existingValue = await stateAdapter.get(listKey);
+        const existingEntries = Array.isArray(existingValue) ? existingValue.map(decode) : (await stateAdapter.getList(listKey)).map(decode);
+        await stateAdapter.set(
+          listKey,
+          [...existingEntries, ...entries],
+          Math.max(1, ttlMs)
+        );
+      } finally {
+        await stateAdapter.releaseLock(lock);
+      }
+    },
+    async read(scope) {
+      const listKey = rawKey(scope);
+      const value = await stateAdapter.get(listKey);
+      if (Array.isArray(value)) {
+        return value.map(decode);
+      }
+      const values = await stateAdapter.getList(listKey);
+      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 loadActivityEntries(args) {
+  const entries = await loadEntries(args);
+  return projectionEntries(entries, args.sessionId).filter(isActivityEntry);
+}
+async function loadMessages(args) {
+  const messageCount = normalizeMessageCount(args.messageCount);
+  if (messageCount === 0) {
+    return [];
+  }
+  const store = args.store ?? await defaultStore();
+  const messages = projectMessages(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).messages;
+}
+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 recordToolExecutionStarted(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const sessionId = args.sessionId ?? currentSessionId(entries);
+  await store.append({
+    scope: args,
+    entries: [
+      toolExecutionStartedEntry({
+        args: args.args,
+        createdAtMs: args.createdAtMs ?? Date.now(),
+        sessionId,
+        toolCallId: args.toolCallId,
+        toolName: args.toolName
+      })
+    ],
+    ttlMs: args.ttlMs
+  });
+}
+async function recordSubagentStarted(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const sessionId = args.sessionId ?? currentSessionId(entries);
+  await store.append({
+    scope: args,
+    entries: [
+      subagentStartedEntry({
+        createdAtMs: args.createdAtMs ?? Date.now(),
+        historyMode: args.historyMode,
+        parentConversationId: args.parentConversationId,
+        parentSessionId: args.parentSessionId,
+        parentToolCallId: args.parentToolCallId,
+        sessionId,
+        subagentInvocationId: args.subagentInvocationId,
+        subagentKind: args.subagentKind,
+        transcriptRef: args.transcriptRef
+      })
+    ],
+    ttlMs: args.ttlMs
+  });
+}
+async function recordSubagentEnded(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const sessionId = args.sessionId ?? currentSessionId(entries);
+  await store.append({
+    scope: args,
+    entries: [
+      subagentEndedEntry({
+        createdAtMs: args.createdAtMs ?? Date.now(),
+        errorCode: args.errorCode,
+        outcome: args.outcome,
+        sessionId,
+        subagentInvocationId: args.subagentInvocationId,
+        transcriptEndMessageIndex: args.transcriptEndMessageIndex,
+        transcriptStartMessageIndex: args.transcriptStartMessageIndex
+      })
+    ],
+    ttlMs: args.ttlMs
+  });
+}
+async function commitMessages(args) {
+  const store = args.store ?? await defaultStore();
+  const entries = await store.read(args);
+  const existingProjection = project(entries);
+  const currentId = currentSessionId(entries);
+  const commit = commitEntries(
+    existingProjection.messages,
+    args.messages,
+    currentId,
+    entries,
+    existingProjection.requester,
+    args.requester
+  );
+  await store.append({
+    scope: args,
+    entries: commit.entries,
+    ttlMs: args.ttlMs
+  });
+  return {
+    sessionId: commit.sessionId
+  };
+}
+
+// src/chat/xml.ts
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
+// src/chat/state/turn-session.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+import {
+  sourceSchema
+} from "@sentry/junior-plugin-api";
+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 toNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? 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 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 parseAgentTurnSurface(value) {
+  return value === "slack" || value === "api" || value === "scheduler" || value === "internal" ? value : void 0;
+}
+function conversationExecutionFromSummary(summary) {
+  const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
+  return {
+    status,
+    runId: summary.sessionId,
+    updatedAtMs: summary.updatedAtMs
+  };
+}
+function parseSource(value) {
+  const result = sourceSchema.safeParse(value);
+  return result.success ? result.data : void 0;
+}
+function sessionLogRequester(requester) {
+  return requester?.platform === "slack" ? toStoredSlackRequester(requester) : 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 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) ?? 0;
+  const cumulativeUsage = parseAgentTurnUsage(parsed.cumulativeUsage);
+  const lastProgressAtMs = toFiniteNonNegativeNumber(parsed.lastProgressAtMs);
+  const logSessionId = typeof parsed.logSessionId === "string" ? parsed.logSessionId : void 0;
+  const requester = parsed.requester === void 0 ? void 0 : parseRequester(parsed.requester);
+  const startedAtMs = toFiniteNonNegativeNumber(parsed.startedAtMs);
+  const surface = parseAgentTurnSurface(parsed.surface);
+  const turnStartMessageIndex = toNonNegativeInteger(
+    parsed.turnStartMessageIndex
+  );
+  const destination = parsed.destination === void 0 ? void 0 : parseDestination(parsed.destination);
+  const source = parsed.source === void 0 ? void 0 : parseSource(parsed.source);
+  if (typeof conversationId !== "string" || typeof sessionId !== "string" || sliceId === void 0 || version === void 0 || updatedAtMs === void 0 || parsed.destination !== void 0 && !destination || parsed.source !== void 0 && !source || parsed.requester !== void 0 && !requester) {
+    return void 0;
+  }
+  return {
+    version,
+    ...channelName ? { channelName } : {},
+    conversationId,
+    sessionId,
+    sliceId,
+    state: status,
+    startedAtMs: startedAtMs ?? updatedAtMs,
+    lastProgressAtMs: lastProgressAtMs ?? updatedAtMs,
+    updatedAtMs,
+    cumulativeDurationMs,
+    ...logSessionId ? { logSessionId } : {},
+    ...cumulativeUsage ? { cumulativeUsage } : {},
+    ...destination ? { destination } : {},
+    ...source ? { source } : {},
+    ...requester ? { requester } : {},
+    ...Array.isArray(parsed.loadedSkillNames) ? {
+      loadedSkillNames: parsed.loadedSkillNames.filter(
+        (value) => typeof value === "string"
+      )
+    } : {},
+    ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" || parsed.resumeReason === "yield" ? { resumeReason: parsed.resumeReason } : {},
+    ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
+    ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {},
+    ...surface ? { surface } : {},
+    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {},
+    ...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,
+    turnStartMessageIndex: _turnStartMessageIndex,
+    ...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 }
+    )
+  ]);
+}
+async function recordConversationActivityMetadata(args) {
+  const conversationStore = args.conversationStore ?? getConversationStore();
+  const source = args.summary.destination?.platform === "local" ? "local" : args.summary.surface;
+  try {
+    await conversationStore.recordActivity({
+      activityAtMs: args.summary.updatedAtMs,
+      channelName: args.summary.channelName,
+      conversationId: args.summary.conversationId,
+      destination: args.summary.destination,
+      nowMs: args.nowMs,
+      requester: sessionLogRequester(args.summary.requester),
+      source,
+      visibility: args.destinationVisibility
+    });
+    await conversationStore.recordExecution({
+      channelName: args.summary.channelName,
+      conversationId: args.summary.conversationId,
+      createdAtMs: args.summary.startedAtMs,
+      destination: args.summary.destination,
+      execution: conversationExecutionFromSummary(args.summary),
+      lastActivityAtMs: args.summary.updatedAtMs,
+      requester: sessionLogRequester(args.summary.requester),
+      source,
+      updatedAtMs: args.nowMs,
+      visibility: args.destinationVisibility
+    });
+  } catch (error) {
+    logWarn(
+      "conversation_activity_metadata_update_failed",
+      { conversationId: args.summary.conversationId },
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to update conversation activity metadata"
+    );
+  }
+}
+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 } : {},
+    conversationId: stored.conversationId,
+    sessionId: stored.sessionId,
+    sliceId: stored.sliceId,
+    state: stored.state,
+    startedAtMs: stored.startedAtMs,
+    lastProgressAtMs: stored.lastProgressAtMs,
+    updatedAtMs: stored.updatedAtMs,
+    piMessages,
+    cumulativeDurationMs: stored.cumulativeDurationMs,
+    ...stored.destination ? { destination: stored.destination } : {},
+    ...stored.source ? { source: stored.source } : {},
+    ...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.surface ? { surface: stored.surface } : {},
+    ...stored.traceId ? { traceId: stored.traceId } : {},
+    ...stored.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: stored.turnStartMessageIndex } : {}
+  };
+}
+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 } : {},
+    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 } : {},
+    cumulativeDurationMs: args.cumulativeDurationMs,
+    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
+    ...args.destination ? { destination: args.destination } : {},
+    ...args.source ? { source: args.source } : {},
+    ...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.surface ? { surface: args.surface } : {},
+    ...args.traceId ? { traceId: args.traceId } : {},
+    ...args.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.turnStartMessageIndex } : {}
+  };
+}
+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,
+    turnStartMessageIndex: _turnStartMessageIndex,
+    ...summary
+  } = args.record;
+  await appendAgentTurnSessionSummary(summary, args.ttlMs);
+  await recordConversationActivityMetadata({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    nowMs: Date.now(),
+    summary
+  });
+  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 } : {},
+      startedAtMs: parsed.startedAtMs,
+      lastProgressAtMs: parsed.lastProgressAtMs,
+      previousVersion: parsed.version,
+      ...parsed.logSessionId ? { logSessionId: parsed.logSessionId } : {},
+      cumulativeDurationMs: args.existing.cumulativeDurationMs,
+      ...args.existing.cumulativeUsage ? { cumulativeUsage: args.existing.cumulativeUsage } : {},
+      ...args.existing.destination ? { destination: args.existing.destination } : {},
+      ...args.existing.source ? { source: args.existing.source } : {},
+      ...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.surface ? { surface: args.existing.surface } : {},
+      ...args.existing.traceId ? { traceId: args.existing.traceId } : {},
+      ...args.existing.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.existing.turnStartMessageIndex } : {},
+      ...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,
+    requester: sessionLogRequester(args.requester ?? existingRecord?.requester),
+    ttlMs
+  });
+  return await setStoredRecord({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    piMessages: args.piMessages,
+    ttlMs,
+    record: buildStoredRecord({
+      ...args.channelName ?? existingRecord?.channelName ? { channelName: args.channelName ?? existingRecord?.channelName } : {},
+      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,
+      cumulativeDurationMs: toFiniteNonNegativeNumber(args.cumulativeDurationMs) ?? existingRecord?.cumulativeDurationMs ?? 0,
+      ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
+      ...args.destination ?? existingRecord?.destination ? { destination: args.destination ?? existingRecord?.destination } : {},
+      ...args.source ?? existingRecord?.source ? { source: args.source ?? existingRecord?.source } : {},
+      ...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.surface ?? existingRecord?.surface ? { surface: args.surface ?? existingRecord?.surface } : {},
+      ...args.traceId ?? existingRecord?.traceId ? { traceId: args.traceId ?? existingRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? existingRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? existingRecord?.turnStartMessageIndex
+      } : {}
+    })
+  });
+}
+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);
+  const summary = {
+    version: existing?.version ?? 0,
+    ...args.channelName ?? existing?.channelName ? { channelName: args.channelName ?? existing?.channelName } : {},
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    startedAtMs: existing?.startedAtMs ?? args.startedAtMs ?? nowMs,
+    lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+    state: args.state,
+    updatedAtMs: nowMs,
+    cumulativeDurationMs: toFiniteNonNegativeNumber(args.cumulativeDurationMs) ?? existing?.cumulativeDurationMs ?? 0,
+    ...args.cumulativeUsage ?? existing?.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage ?? existing?.cumulativeUsage } : {},
+    ...args.destination ?? existing?.destination ? { destination: args.destination ?? existing?.destination } : {},
+    ...args.source ?? existing?.source ? { source: args.source ?? existing?.source } : {},
+    ...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.surface ?? existing?.surface ? { surface: args.surface ?? existing?.surface } : {},
+    ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
+  };
+  await appendAgentTurnSessionSummary(summary, ttlMs);
+  await recordConversationActivityMetadata({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    nowMs,
+    summary
+  });
+}
+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 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/interruption-marker.ts
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+function getInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+
+export {
+  piContentMessageSchema,
+  loadActivityEntries,
+  loadProjection,
+  loadConnectedMcpProviders,
+  recordMcpProviderConnected,
+  recordAuthorizationRequested,
+  recordAuthorizationCompleted,
+  recordToolExecutionStarted,
+  recordSubagentStarted,
+  recordSubagentEnded,
+  commitMessages,
+  escapeXml,
+  getAgentTurnSessionRecord,
+  upsertAgentTurnSessionRecord,
+  recordAgentTurnSessionSummary,
+  listAgentTurnSessionSummariesForConversation,
+  abandonAgentTurnSessionRecord,
+  failAgentTurnSessionRecord,
+  getInterruptionMarker
+};