@sentry/junior 0.108.0 → 0.109.0

package/dist/chunk-J3B3FPP2.js

@@ -1,1061 +0,0 @@
-import {
-  agentTurnUsageSchema
-} from "./chunk-MU6HHZEN.js";
-import {
-  getStateAdapter
-} from "./chunk-H3QYZL7K.js";
-import {
-  contextProvenance,
-  createSqlConversationEventStore,
-  getConversationEventStore,
-  getConversationStore,
-  getSqlExecutor,
-  instructionActors,
-  instructionProvenanceFor,
-  sanitizePostgresJson,
-  withConversationEventLock
-} from "./chunk-TE4QHJH4.js";
-import {
-  retainRuntimeTurnContext,
-  stripRuntimeTurnContext
-} from "./chunk-SS67LUOK.js";
-import {
-  toStoredSlackActor
-} from "./chunk-VIXFG2VC.js";
-import {
-  logWarn
-} from "./chunk-O24R4DCK.js";
-import {
-  isRecord,
-  toOptionalNumber,
-  toOptionalString
-} from "./chunk-OB42YVAE.js";
-
-// src/chat/conversations/projection.ts
-import { isDeepStrictEqual } from "util";
-
-// 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/pi/conversation-events.ts
-function authorizationObservationMessage(data, createdAtMs) {
-  const label = data.kind === "mcp" ? "MCP authorization" : "Authorization";
-  return piMessageSchema.parse({
-    role: "user",
-    content: [
-      {
-        type: "text",
-        text: `${label} completed for provider "${data.provider}". Continue the blocked request and retry the provider operation if needed.`
-      }
-    ],
-    timestamp: createdAtMs
-  });
-}
-function messageEventProvenance(data) {
-  return data.provenance ?? contextProvenance;
-}
-function durableMessages(message) {
-  return stripRuntimeTurnContext([piMessageSchema.parse(message)]);
-}
-function projectConversationEvents(events, options) {
-  const messages = [];
-  const provenance = [];
-  const seqs = [];
-  let modelProfile = "standard";
-  let modelId;
-  for (const event of events) {
-    if (options?.maxSeq !== void 0 && event.seq > options.maxSeq) break;
-    if (event.data.type === "unknown") {
-      throw new Error(
-        `Unsupported conversation event "${event.data.originalType}" at seq ${event.seq} (schema version ${event.schemaVersion})`
-      );
-    }
-    if (event.data.type === "compaction" || event.data.type === "handoff" || event.data.type === "rollback") {
-      modelProfile = event.data.modelProfile;
-      modelId = event.data.modelId;
-      for (const replacement of event.data.replacementHistory) {
-        for (const message of durableMessages(replacement.message)) {
-          messages.push(message);
-          provenance.push(replacement.provenance ?? contextProvenance);
-          seqs.push(replacement.sourceEventSeq ?? event.seq);
-        }
-      }
-      continue;
-    }
-    if (event.data.type === "agent_step") {
-      for (const message of durableMessages(event.data.message)) {
-        messages.push(message);
-        provenance.push(messageEventProvenance(event.data));
-        seqs.push(event.seq);
-      }
-      continue;
-    }
-    if (event.data.type === "authorization_completed") {
-      messages.push(
-        authorizationObservationMessage(event.data, event.createdAtMs)
-      );
-      provenance.push(contextProvenance);
-      seqs.push(event.seq);
-    }
-  }
-  return { messages, provenance, seqs, modelProfile, modelId };
-}
-
-// src/chat/conversations/projection.ts
-function connectedMcpProvidersFromEvents(events) {
-  const providers = /* @__PURE__ */ new Set();
-  for (const event of events) {
-    if (event.data.type === "mcp_provider_connected") {
-      providers.add(event.data.provider);
-    }
-  }
-  return [...providers].sort((left, right) => left.localeCompare(right));
-}
-function isUserMessage(message) {
-  return message.role === "user";
-}
-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 normalizeDurableMessage(message) {
-  return piMessageSchema.parse(
-    JSON.parse(JSON.stringify(sanitizePostgresJson(message)))
-  );
-}
-function resolveCommitProvenance(args) {
-  if (args.explicitProvenance) {
-    if (args.explicitProvenance.length !== args.nextMessages.length) {
-      throw new Error("commit provenance must align one-to-one with messages");
-    }
-    return args.explicitProvenance;
-  }
-  const matchingPrefix = args.matchingPrefix;
-  const provenance = args.nextMessages.map(
-    (_, index) => index < matchingPrefix ? args.existing.provenance[index] ?? contextProvenance : contextProvenance
-  );
-  if (args.newMessageProvenance) {
-    for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) {
-      if (isUserMessage(args.nextMessages[index])) {
-        provenance[index] = args.newMessageProvenance;
-        break;
-      }
-    }
-  }
-  if (args.trailingMessageProvenance) {
-    if (args.trailingMessageProvenance.length > provenance.length) {
-      throw new Error(
-        "trailing commit provenance cannot exceed committed messages"
-      );
-    }
-    const newMessageCount = args.nextMessages.length - matchingPrefix;
-    if (args.trailingMessageProvenance.length > newMessageCount) {
-      throw new Error(
-        "trailing commit provenance must align to newly committed messages"
-      );
-    }
-    const start = provenance.length - args.trailingMessageProvenance.length;
-    args.trailingMessageProvenance.forEach((entry, offset) => {
-      provenance[start + offset] = entry;
-    });
-  }
-  return provenance;
-}
-async function loadProjection(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return projectConversationEvents(events).messages;
-}
-async function loadConversationProjection(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return projectConversationEvents(events);
-}
-async function openConversationProjection(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return projectConversationEvents(events);
-}
-async function loadTurnProjection(args) {
-  const eventStore = getConversationEventStore();
-  if (args.committedSeq < 0) {
-    return projectConversationEvents(
-      await eventStore.loadCurrentHistory(args.conversationId)
-    );
-  }
-  const historyEvents = await eventStore.loadHistoryContaining(
-    args.conversationId,
-    args.committedSeq,
-    args.includeTail ? void 0 : args.committedSeq
-  );
-  if (!historyEvents) {
-    return void 0;
-  }
-  return projectConversationEvents(historyEvents);
-}
-async function loadConnectedMcpProviders(args) {
-  const events = await getConversationEventStore().loadCurrentHistory(
-    args.conversationId
-  );
-  return connectedMcpProvidersFromEvents(events);
-}
-function messageTimestamp(message) {
-  const timestamp = message.timestamp;
-  return typeof timestamp === "number" ? timestamp : Date.now();
-}
-async function commitMessages(args) {
-  const executor = args.executor ?? getSqlExecutor();
-  return await withConversationEventLock(
-    executor,
-    args.conversationId,
-    async () => executor.transaction(
-      async () => await commitMessagesLocked(args, executor)
-    )
-  );
-}
-async function commitMessagesLocked(args, executor) {
-  const eventStore = createSqlConversationEventStore(executor);
-  const currentEvents = await eventStore.loadCurrentHistory(
-    args.conversationId
-  );
-  const current = projectConversationEvents(currentEvents);
-  const nextLocalMessages = stripRuntimeTurnContext(args.messages).map(
-    normalizeDurableMessage
-  );
-  const matchingPrefix = countMatchingPrefix(
-    current.messages,
-    nextLocalMessages
-  );
-  const nextLocalProvenance = resolveCommitProvenance({
-    existing: current,
-    nextMessages: nextLocalMessages,
-    matchingPrefix,
-    ...args.provenance ? { explicitProvenance: args.provenance } : {},
-    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {},
-    ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : {}
-  });
-  if (matchingPrefix === current.messages.length) {
-    const newMessages = nextLocalMessages.slice(matchingPrefix);
-    await eventStore.append(
-      args.conversationId,
-      newMessages.map((message, index) => ({
-        data: {
-          type: "agent_step",
-          message,
-          provenance: nextLocalProvenance[matchingPrefix + index]
-        },
-        createdAtMs: messageTimestamp(message)
-      }))
-    );
-  } else {
-    throw new Error(
-      `Agent history for ${args.conversationId} changed before its committed boundary`
-    );
-  }
-  const committedEvents = await eventStore.loadCurrentHistory(
-    args.conversationId
-  );
-  const committed = projectConversationEvents(committedEvents);
-  return {
-    committedSeq: committedEvents.at(-1)?.seq ?? -1,
-    historyVersion: committedEvents.at(-1)?.historyVersion ?? 0,
-    messageSeqs: committed.seqs,
-    messages: nextLocalMessages,
-    provenance: nextLocalProvenance
-  };
-}
-async function recordMcpProviderConnected(args) {
-  const eventStore = getConversationEventStore();
-  const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (connectedMcpProvidersFromEvents(events).includes(args.provider)) {
-    return;
-  }
-  await eventStore.append(args.conversationId, [
-    {
-      data: { type: "mcp_provider_connected", provider: args.provider },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordAuthorizationRequested(args) {
-  const eventStore = getConversationEventStore();
-  const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (events.some(
-    (event) => event.data.type === "authorization_requested" && event.data.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await eventStore.append(args.conversationId, [
-    {
-      data: {
-        type: "authorization_requested",
-        kind: args.kind,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId,
-        delivery: args.delivery
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordAuthorizationCompleted(args) {
-  const eventStore = getConversationEventStore();
-  const events = await eventStore.loadCurrentHistory(args.conversationId);
-  if (events.some(
-    (event) => event.data.type === "authorization_completed" && event.data.authorizationId === args.authorizationId
-  )) {
-    return;
-  }
-  await eventStore.append(args.conversationId, [
-    {
-      data: {
-        type: "authorization_completed",
-        kind: args.kind,
-        provider: args.provider,
-        actorId: args.actorId,
-        authorizationId: args.authorizationId
-      },
-      createdAtMs: Date.now()
-    }
-  ]);
-}
-async function recordToolExecutionStarted(args) {
-  await getConversationEventStore().append(args.conversationId, [
-    {
-      data: {
-        type: "tool_execution_started",
-        toolCallId: args.toolCallId,
-        toolName: args.toolName
-      },
-      createdAtMs: args.createdAtMs ?? Date.now()
-    }
-  ]);
-}
-
-// src/chat/state/conversation.ts
-function defaultConversationState() {
-  const nowMs = Date.now();
-  return {
-    schemaVersion: 1,
-    messages: [],
-    compactions: [],
-    backfill: {},
-    processing: {},
-    stats: {
-      estimatedContextTokens: 0,
-      totalMessageCount: 0,
-      compactedMessageCount: 0,
-      updatedAtMs: nowMs
-    },
-    vision: {
-      byFileId: {}
-    }
-  };
-}
-function coercePendingAuthState(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const kind = value.kind;
-  const provider = toOptionalString(value.provider);
-  const actorId = toOptionalString(value.actorId);
-  const authSessionId = toOptionalString(value.authSessionId);
-  const scope = toOptionalString(value.scope);
-  const sessionId = toOptionalString(value.sessionId);
-  const linkSentAtMs = toOptionalNumber(value.linkSentAtMs);
-  if (kind !== "mcp" && kind !== "plugin" || !provider || !actorId || kind === "mcp" && !authSessionId || !sessionId || typeof linkSentAtMs !== "number") {
-    return void 0;
-  }
-  const base = {
-    provider,
-    actorId,
-    ...scope ? { scope } : {},
-    sessionId,
-    linkSentAtMs
-  };
-  return kind === "mcp" ? { ...base, authSessionId, kind } : { ...base, kind };
-}
-function coerceThreadConversationState(value) {
-  if (!isRecord(value)) {
-    return defaultConversationState();
-  }
-  const root = value;
-  const rawConversation = isRecord(root.conversation) ? root.conversation : {};
-  const base = defaultConversationState();
-  const messages = [];
-  const compactions = [];
-  const rawBackfill = isRecord(rawConversation.backfill) ? rawConversation.backfill : {};
-  const backfill = {
-    completedAtMs: toOptionalNumber(rawBackfill.completedAtMs),
-    source: rawBackfill.source === "recent_messages" || rawBackfill.source === "thread_fetch" ? rawBackfill.source : void 0
-  };
-  const rawProcessing = isRecord(rawConversation.processing) ? rawConversation.processing : {};
-  const processing = {
-    activeTurnId: toOptionalString(rawProcessing.activeTurnId),
-    lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
-    pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
-  };
-  const rawStats = isRecord(rawConversation.stats) ? rawConversation.stats : {};
-  const stats = {
-    estimatedContextTokens: toOptionalNumber(rawStats.estimatedContextTokens) ?? base.stats.estimatedContextTokens,
-    totalMessageCount: toOptionalNumber(rawStats.totalMessageCount) ?? messages.length,
-    compactedMessageCount: toOptionalNumber(rawStats.compactedMessageCount) ?? 0,
-    updatedAtMs: toOptionalNumber(rawStats.updatedAtMs) ?? base.stats.updatedAtMs
-  };
-  const rawVision = isRecord(rawConversation.vision) ? rawConversation.vision : {};
-  const rawVisionByFileId = isRecord(rawVision.byFileId) ? rawVision.byFileId : {};
-  const byFileId = {};
-  for (const [fileId, value2] of Object.entries(rawVisionByFileId)) {
-    if (typeof fileId !== "string" || fileId.trim().length === 0) continue;
-    if (!isRecord(value2)) continue;
-    const summary = toOptionalString(value2.summary);
-    const analyzedAtMs = toOptionalNumber(value2.analyzedAtMs);
-    if (!summary || !analyzedAtMs) continue;
-    byFileId[fileId] = {
-      summary,
-      analyzedAtMs
-    };
-  }
-  return {
-    schemaVersion: 1,
-    messages,
-    compactions,
-    backfill,
-    processing,
-    stats,
-    vision: {
-      backfillCompletedAtMs: toOptionalNumber(rawVision.backfillCompletedAtMs),
-      byFileId
-    }
-  };
-}
-function buildConversationStatePatch(conversation) {
-  const {
-    compactions: _compactions,
-    messages: _messages,
-    ...scratch
-  } = conversation;
-  return {
-    conversation: {
-      ...scratch,
-      schemaVersion: 1,
-      stats: {
-        ...conversation.stats,
-        totalMessageCount: conversation.messages.length,
-        updatedAtMs: Date.now()
-      }
-    }
-  };
-}
-
-// src/chat/state/turn-session.ts
-import { THREAD_STATE_TTL_MS } from "chat";
-import {
-  actorSchema,
-  destinationSchema,
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-
-// src/chat/state/turn-session-keys.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function agentTurnSessionConversationIndexKey(conversationId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
-}
-
-// src/chat/state/turn-session.ts
-var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX}:index`;
-var AGENT_TURN_SESSION_INDEX_MAX_LENGTH = 5e3;
-var AGENT_TURN_SESSION_INDEX_READ_CONCURRENCY = 25;
-var AGENT_TURN_SESSION_TTL_MS = THREAD_STATE_TTL_MS;
-var agentTurnSessionStatusSchema = z2.enum([
-  "running",
-  "awaiting_resume",
-  "completed",
-  "failed",
-  "abandoned"
-]);
-var agentTurnSurfaceSchema = z2.enum([
-  "slack",
-  "api",
-  "scheduler",
-  "internal"
-]);
-var agentTurnResumeReasonSchema = z2.enum([
-  "timeout",
-  "auth",
-  "yield",
-  "retry"
-]);
-var nonNegativeNumberSchema = z2.number().finite().nonnegative();
-var seqCursorSchema = z2.number().int().min(-1);
-var agentTurnSessionSummarySchema = z2.object({
-  channelName: z2.string().min(1).optional(),
-  version: z2.number().int().nonnegative(),
-  conversationId: z2.string().min(1),
-  cumulativeDurationMs: nonNegativeNumberSchema,
-  cumulativeUsage: agentTurnUsageSchema.optional(),
-  destination: destinationSchema.optional(),
-  source: sourceSchema.optional(),
-  lastProgressAtMs: nonNegativeNumberSchema,
-  loadedSkillNames: z2.array(z2.string()).optional(),
-  modelId: z2.string().min(1).optional(),
-  reasoningLevel: z2.string().min(1).optional(),
-  actor: actorSchema.optional(),
-  resumeReason: agentTurnResumeReasonSchema.optional(),
-  resumedFromSliceId: z2.number().int().nonnegative().optional(),
-  sessionId: z2.string().min(1),
-  sliceId: z2.number().int().nonnegative(),
-  startedAtMs: nonNegativeNumberSchema,
-  state: agentTurnSessionStatusSchema,
-  surface: agentTurnSurfaceSchema.optional(),
-  traceId: z2.string().optional(),
-  updatedAtMs: nonNegativeNumberSchema
-}).strict();
-var storedAgentTurnSessionRecordSchema = agentTurnSessionSummarySchema.extend({
-  actors: z2.array(actorSchema).optional(),
-  committedSeq: seqCursorSchema,
-  historyVersion: z2.number().int().nonnegative().optional(),
-  errorMessage: z2.string().optional(),
-  turnStartSeq: seqCursorSchema.optional(),
-  runtimeContext: z2.array(piMessageSchema).optional()
-}).strict();
-function conversationExecutionFromSummary(summary) {
-  const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
-  return {
-    status,
-    runId: summary.sessionId,
-    updatedAtMs: summary.updatedAtMs
-  };
-}
-function sessionLogActor(actor) {
-  return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
-}
-function parseAgentTurnSessionRecord(value) {
-  return storedAgentTurnSessionRecordSchema.parse(value);
-}
-function parseAgentTurnSessionSummary(value) {
-  return agentTurnSessionSummarySchema.parse(value);
-}
-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;
-  await conversationStore.recordActivity({
-    activityAtMs: args.summary.updatedAtMs,
-    channelName: args.summary.channelName,
-    conversationId: args.summary.conversationId,
-    destination: args.summary.destination,
-    nowMs: args.nowMs,
-    actor: sessionLogActor(args.summary.actor),
-    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,
-    metrics: {
-      durationMs: args.summary.cumulativeDurationMs,
-      ...args.summary.cumulativeUsage ? { usage: args.summary.cumulativeUsage } : {}
-    },
-    actor: sessionLogActor(args.summary.actor),
-    source,
-    updatedAtMs: args.nowMs,
-    visibility: args.destinationVisibility
-  });
-}
-function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessageIndex, restoreVolatileContext = true) {
-  const piMessages = restoreVolatileContext && (stored.state === "running" || stored.state === "awaiting_resume") ? restoreRuntimeContext(piProjection.messages, stored.runtimeContext) : piProjection.messages;
-  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,
-    piMessageProvenance: piProjection.provenance,
-    actors: stored.actors ?? instructionActors(piProjection.provenance),
-    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.modelId ? { modelId: stored.modelId } : {},
-    ...stored.reasoningLevel ? { reasoningLevel: stored.reasoningLevel } : {},
-    ...stored.actor ? { actor: stored.actor } : {},
-    ...stored.resumedFromSliceId !== void 0 ? { resumedFromSliceId: stored.resumedFromSliceId } : {},
-    ...stored.surface ? { surface: stored.surface } : {},
-    ...stored.traceId ? { traceId: stored.traceId } : {},
-    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
-  };
-}
-function restoreRuntimeContext(messages, runtimeContext) {
-  if (!runtimeContext || runtimeContext.length === 0) return messages;
-  const restored = [...messages];
-  for (const runtimeMessage of runtimeContext) {
-    const runtime = runtimeMessage;
-    const targetIndex = restored.findIndex((message) => {
-      const candidate = message;
-      return candidate.role === "user" && candidate.timestamp === runtime.timestamp;
-    });
-    if (targetIndex < 0) {
-      restored.push(runtimeMessage);
-      continue;
-    }
-    const target = restored[targetIndex];
-    restored[targetIndex] = {
-      ...restored[targetIndex],
-      content: [
-        ...Array.isArray(runtime.content) ? runtime.content : [],
-        ...Array.isArray(target.content) ? target.content : []
-      ]
-    };
-  }
-  return restored;
-}
-async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  return value == null ? void 0 : parseAgentTurnSessionRecord(value);
-}
-async function materializeStoredAgentTurnSessionRecord(conversationId, sessionId, followCurrentReplacement) {
-  const parsed = await getStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId
-  );
-  if (!parsed) {
-    return void 0;
-  }
-  const pinnedProjection = await loadTurnProjection({
-    conversationId,
-    committedSeq: parsed.committedSeq,
-    // Unfinished records include the current-epoch tail so parked input
-    // appended after the last safe boundary stays model-visible on resume.
-    includeTail: parsed.state === "running" || parsed.state === "awaiting_resume"
-  });
-  if (!pinnedProjection) {
-    return void 0;
-  }
-  const currentHistory = await getConversationEventStore().loadCurrentHistory(conversationId);
-  const currentHistoryVersion = currentHistory.at(-1)?.historyVersion ?? parsed.historyVersion ?? 0;
-  const followsReplacement = followCurrentReplacement && (parsed.state === "running" || parsed.state === "awaiting_resume") && parsed.historyVersion !== void 0 && parsed.historyVersion !== currentHistoryVersion;
-  const piProjection = followsReplacement ? projectConversationEvents(currentHistory) : pinnedProjection;
-  const turnStartMessageIndex = followsReplacement ? 0 : parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
-  return materializeAgentTurnSessionRecord(
-    parsed,
-    piProjection,
-    turnStartMessageIndex,
-    !followsReplacement && (parsed.historyVersion === void 0 || parsed.historyVersion === currentHistoryVersion)
-  );
-}
-async function getAgentTurnSessionRecord(conversationId, sessionId) {
-  return await materializeStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId,
-    false
-  );
-}
-async function getAgentTurnSessionRecordForResume(conversationId, sessionId) {
-  return await materializeStoredAgentTurnSessionRecord(
-    conversationId,
-    sessionId,
-    true
-  );
-}
-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,
-    committedSeq: args.committedSeq,
-    ...args.historyVersion !== void 0 ? { historyVersion: args.historyVersion } : {},
-    ...args.turnStartSeq !== void 0 ? { turnStartSeq: args.turnStartSeq } : {},
-    ...args.runtimeContext && args.runtimeContext.length > 0 ? { runtimeContext: args.runtimeContext } : {},
-    cumulativeDurationMs: args.cumulativeDurationMs,
-    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
-    ...args.destination ? { destination: args.destination } : {},
-    ...args.source ? { source: args.source } : {},
-    ...args.actor ? { actor: args.actor } : {},
-    ...args.actors ? { actors: args.actors } : {},
-    ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
-    ...args.modelId ? { modelId: args.modelId } : {},
-    ...args.reasoningLevel ? { reasoningLevel: args.reasoningLevel } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
-    ...args.surface ? { surface: args.surface } : {},
-    ...args.traceId ? { traceId: args.traceId } : {}
-  };
-}
-async function setStoredRecord(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  await recordConversationActivityMetadata({
-    conversationStore: args.conversationStore,
-    destinationVisibility: args.destinationVisibility,
-    nowMs: Date.now(),
-    summary: args.record
-  });
-  await stateAdapter.set(
-    agentTurnSessionKey(args.record.conversationId, args.record.sessionId),
-    args.record,
-    args.ttlMs
-  );
-  const {
-    actors: _actors,
-    committedSeq: _committedSeq,
-    historyVersion: _historyVersion,
-    errorMessage: _errorMessage,
-    turnStartSeq: _turnStartSeq,
-    runtimeContext: _runtimeContext,
-    ...summary
-  } = args.record;
-  await appendAgentTurnSessionSummary(summary, args.ttlMs);
-  return materializeAgentTurnSessionRecord(
-    args.record,
-    {
-      messages: [...args.piMessages],
-      provenance: [...args.piMessageProvenance]
-    },
-    args.turnStartMessageIndex
-  );
-}
-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,
-    piMessageProvenance: args.existing.piMessageProvenance,
-    ttlMs: AGENT_TURN_SESSION_TTL_MS,
-    ...args.existing.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.existing.turnStartMessageIndex } : {},
-    record: buildStoredRecord({
-      conversationId: args.existing.conversationId,
-      sessionId: args.existing.sessionId,
-      sliceId: args.existing.sliceId,
-      state: args.state,
-      committedSeq: parsed.committedSeq,
-      ...parsed.historyVersion !== void 0 ? { historyVersion: parsed.historyVersion } : {},
-      ...parsed.turnStartSeq !== void 0 ? { turnStartSeq: parsed.turnStartSeq } : {},
-      ...parsed.runtimeContext ? { runtimeContext: parsed.runtimeContext } : {},
-      ...parsed.channelName ? { channelName: parsed.channelName } : {},
-      startedAtMs: parsed.startedAtMs,
-      lastProgressAtMs: parsed.lastProgressAtMs,
-      previousVersion: parsed.version,
-      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.modelId ? { modelId: args.existing.modelId } : {},
-      ...args.existing.reasoningLevel ? { reasoningLevel: args.existing.reasoningLevel } : {},
-      ...args.existing.actor ? { actor: args.existing.actor } : {},
-      actors: args.existing.actors,
-      ...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.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 instructionActor = args.actor ?? existingRecord?.actor;
-  const commit = await commitMessages({
-    conversationId: args.conversationId,
-    messages: args.piMessages,
-    ...instructionActor ? { newMessageProvenance: instructionProvenanceFor(instructionActor) } : {},
-    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {}
-  });
-  const durableTurnStartMessageIndex = args.turnStartMessageIndex === void 0 ? void 0 : stripRuntimeTurnContext(
-    args.piMessages.slice(0, args.turnStartMessageIndex)
-  ).length;
-  const runtimeContext = retainRuntimeTurnContext(args.piMessages);
-  const retainedRuntimeContext = runtimeContext.length > 0 ? runtimeContext : existingRecord?.historyVersion === commit.historyVersion ? existingRecord.runtimeContext : void 0;
-  const turnStartSeq = durableTurnStartMessageIndex === void 0 ? existingRecord?.turnStartSeq : durableTurnStartMessageIndex <= 0 ? -1 : commit.messageSeqs[durableTurnStartMessageIndex - 1] ?? commit.committedSeq;
-  const turnStartMessageIndex = durableTurnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
-  return await setStoredRecord({
-    conversationStore: args.conversationStore,
-    destinationVisibility: args.destinationVisibility,
-    piMessages: commit.messages,
-    piMessageProvenance: commit.provenance,
-    ttlMs,
-    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {},
-    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 } : {},
-      committedSeq: commit.committedSeq,
-      historyVersion: commit.historyVersion,
-      ...turnStartSeq !== void 0 ? { turnStartSeq } : {},
-      ...retainedRuntimeContext ? { runtimeContext: retainedRuntimeContext } : {},
-      previousVersion: existingRecord?.version,
-      cumulativeDurationMs: 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 } : {},
-      modelId: args.modelId,
-      ...args.reasoningLevel ?? existingRecord?.reasoningLevel ? {
-        reasoningLevel: args.reasoningLevel ?? existingRecord?.reasoningLevel
-      } : {},
-      ...args.actor ?? existingRecord?.actor ? { actor: args.actor ?? existingRecord?.actor } : {},
-      actors: instructionActors([
-        ...(existingRecord?.actors ?? []).map(instructionProvenanceFor),
-        ...(args.actors ?? []).map(instructionProvenanceFor),
-        ...commit.provenance
-      ]),
-      ...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 } : {}
-    })
-  });
-}
-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: 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.actor ?? existing?.actor ? { actor: args.actor ?? existing?.actor } : {},
-    ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : existing?.loadedSkillNames ? { loadedSkillNames: existing.loadedSkillNames } : {},
-    ...args.modelId ?? existing?.modelId ? { modelId: args.modelId ?? existing?.modelId } : {},
-    ...args.reasoningLevel ?? existing?.reasoningLevel ? { reasoningLevel: args.reasoningLevel ?? existing?.reasoningLevel } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.surface ?? existing?.surface ? { surface: args.surface ?? existing?.surface } : {},
-    ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
-  };
-  await recordConversationActivityMetadata({
-    conversationStore: args.conversationStore,
-    destinationVisibility: args.destinationVisibility,
-    nowMs,
-    summary
-  });
-  await appendAgentTurnSessionSummary(summary, ttlMs);
-}
-async function readAgentTurnSessionSummariesFromIndex(key, stateAdapter) {
-  await stateAdapter.connect();
-  const values = await stateAdapter.getList(key);
-  const summaries = /* @__PURE__ */ new Map();
-  for (const value of [...values].reverse()) {
-    let summary;
-    try {
-      summary = parseAgentTurnSessionSummary(value);
-    } catch (error) {
-      logWarn(
-        "agent_turn_session_summary_parse_failed",
-        {},
-        {
-          "app.state.key": key,
-          "exception.message": error instanceof Error ? error.message : String(error)
-        },
-        "Skipping an invalid turn-session summary index entry"
-      );
-      continue;
-    }
-    const summaryKey = `${summary.conversationId}:${summary.sessionId}`;
-    if (!summaries.has(summaryKey)) {
-      summaries.set(summaryKey, summary);
-    }
-  }
-  return [...summaries.values()].sort(
-    (left, right) => right.updatedAtMs - left.updatedAtMs
-  );
-}
-async function listAgentTurnSessionSummariesForConversation(conversationId) {
-  const stateAdapter = getStateAdapter();
-  const summaries = await listBoundedAgentTurnSessionSummariesForConversation(conversationId);
-  if (summaries.length > 0) {
-    return summaries;
-  }
-  return (await readAgentTurnSessionSummariesFromIndex(
-    AGENT_TURN_SESSION_INDEX_KEY,
-    stateAdapter
-  )).filter((summary) => summary.conversationId === conversationId);
-}
-async function listBoundedAgentTurnSessionSummariesForConversation(conversationId) {
-  return readAgentTurnSessionSummariesFromIndex(
-    agentTurnSessionConversationIndexKey(conversationId),
-    getStateAdapter()
-  );
-}
-async function listAgentTurnSessionSummariesForConversations(stateAdapter, conversationIds) {
-  const ids = [...new Set(conversationIds)];
-  const globalSummaries = await readAgentTurnSessionSummariesFromIndex(
-    AGENT_TURN_SESSION_INDEX_KEY,
-    stateAdapter
-  );
-  const globalByConversation = /* @__PURE__ */ new Map();
-  for (const summary of globalSummaries) {
-    globalByConversation.set(summary.conversationId, [
-      ...globalByConversation.get(summary.conversationId) ?? [],
-      summary
-    ]);
-  }
-  const summariesByConversation = /* @__PURE__ */ new Map();
-  let nextIndex = 0;
-  const readNext = async () => {
-    while (nextIndex < ids.length) {
-      const conversationId = ids[nextIndex];
-      nextIndex += 1;
-      if (!conversationId) continue;
-      const summaries = await readAgentTurnSessionSummariesFromIndex(
-        agentTurnSessionConversationIndexKey(conversationId),
-        stateAdapter
-      );
-      summariesByConversation.set(
-        conversationId,
-        summaries.length > 0 ? summaries : globalByConversation.get(conversationId) ?? []
-      );
-    }
-  };
-  await Promise.all(
-    Array.from(
-      {
-        length: Math.min(AGENT_TURN_SESSION_INDEX_READ_CONCURRENCY, ids.length)
-      },
-      readNext
-    )
-  );
-  return summariesByConversation;
-}
-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/state/ttl.ts
-var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-
-export {
-  piMessageSchema,
-  loadProjection,
-  loadConversationProjection,
-  openConversationProjection,
-  loadConnectedMcpProviders,
-  commitMessages,
-  recordMcpProviderConnected,
-  recordAuthorizationRequested,
-  recordAuthorizationCompleted,
-  recordToolExecutionStarted,
-  AGENT_TURN_SESSION_PREFIX,
-  agentTurnSessionKey,
-  agentTurnSessionConversationIndexKey,
-  getAgentTurnSessionRecord,
-  getAgentTurnSessionRecordForResume,
-  upsertAgentTurnSessionRecord,
-  recordAgentTurnSessionSummary,
-  listAgentTurnSessionSummariesForConversation,
-  listAgentTurnSessionSummariesForConversations,
-  abandonAgentTurnSessionRecord,
-  failAgentTurnSessionRecord,
-  JUNIOR_THREAD_STATE_TTL_MS,
-  coerceThreadConversationState,
-  buildConversationStatePatch
-};