@sentry/junior 0.88.0 → 0.90.0

package/dist/chunk-ONFOWI2D.js

@@ -0,0 +1,955 @@
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  buildConversationStatePatch
+} from "./chunk-KC42JAAQ.js";
+import {
+  abandonAgentTurnSessionRecord,
+  getAgentTurnSessionRecord,
+  upsertAgentTurnSessionRecord
+} from "./chunk-GCWD2VHP.js";
+import {
+  getStateAdapter
+} from "./chunk-RS6ANWVT.js";
+import {
+  getPiMessageRole,
+  trimTrailingAssistantMessages
+} from "./chunk-HXL2ZV74.js";
+import {
+  getActiveTraceId,
+  logException
+} from "./chunk-ZUK7BL63.js";
+import {
+  isRecord,
+  toOptionalString
+} from "./chunk-OB42YVAE.js";
+
+// src/chat/state/turn-id.ts
+function buildDeterministicTurnId(messageId) {
+  const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `turn_${sanitized}`;
+}
+
+// src/chat/runtime/turn.ts
+var CooperativeTurnYieldError = class extends Error {
+  code = "cooperative_turn_yield";
+  constructor(message = "Agent turn yielded at a safe boundary") {
+    super(message);
+    this.name = "CooperativeTurnYieldError";
+  }
+};
+function isCooperativeTurnYieldError(error) {
+  return error instanceof CooperativeTurnYieldError;
+}
+var TurnInputCommitLostError = class extends Error {
+  code = "turn_input_commit_lost";
+  constructor(message = "Turn input commit lost its durable owner") {
+    super(message);
+    this.name = "TurnInputCommitLostError";
+  }
+};
+function isTurnInputCommitLostError(error) {
+  return error instanceof TurnInputCommitLostError;
+}
+var TurnInputDeferredError = class extends Error {
+  code = "turn_input_deferred";
+  constructor(message = "Turn input is deferred until the active resume ends") {
+    super(message);
+    this.name = "TurnInputDeferredError";
+  }
+};
+function isTurnInputDeferredError(error) {
+  return error instanceof TurnInputDeferredError;
+}
+function startActiveTurn(args) {
+  args.conversation.processing.activeTurnId = args.nextTurnId;
+  args.updateConversationStats(args.conversation);
+}
+function clearActiveTurn(conversation, sessionId) {
+  if (!sessionId || conversation.processing.activeTurnId === sessionId) {
+    conversation.processing.activeTurnId = void 0;
+  }
+}
+function markTurnClosed(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.updateConversationStats(args.conversation);
+}
+function markTurnCompleted(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.updateConversationStats(args.conversation);
+}
+function markTurnFailed(args) {
+  clearActiveTurn(args.conversation, args.sessionId);
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.markConversationMessage(args.conversation, args.userMessageId, {
+    replied: false,
+    skippedReason: "reply failed"
+  });
+  args.updateConversationStats(args.conversation);
+}
+
+// src/chat/usage.ts
+var COMPONENT_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+function hasAgentTurnUsage(usage) {
+  return Boolean(
+    usage && Object.values(usage).some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    )
+  );
+}
+function getFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getComponentTotal(usage) {
+  let total;
+  for (const field of COMPONENT_USAGE_FIELDS) {
+    const value = getFiniteCount(usage[field]);
+    if (value === void 0) continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+}
+function addAgentTurnUsage(...usages) {
+  const components = {};
+  let componentTotal;
+  let totalOnlyTokens;
+  for (const usage of usages) {
+    if (!usage) continue;
+    const usageComponentTotal = getComponentTotal(usage);
+    if (usageComponentTotal !== void 0) {
+      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+      for (const field of COMPONENT_USAGE_FIELDS) {
+        const value = getFiniteCount(usage[field]);
+        if (value === void 0) continue;
+        components[field] = (components[field] ?? 0) + value;
+      }
+      continue;
+    }
+    const totalTokens = getFiniteCount(usage.totalTokens);
+    if (totalTokens !== void 0) {
+      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+    }
+  }
+  if (totalOnlyTokens !== void 0) {
+    return {
+      totalTokens: totalOnlyTokens + (componentTotal ?? 0)
+    };
+  }
+  return hasAgentTurnUsage(components) ? components : void 0;
+}
+
+// src/chat/services/turn-session-record.ts
+var AGENT_CONTINUE_MAX_SLICES = 48;
+function logSessionRecordError(error, eventName, args, attributes, message) {
+  logException(
+    error,
+    eventName,
+    {
+      slackThreadId: args.logContext.threadId,
+      slackUserId: args.logContext.requesterId,
+      slackChannelId: args.logContext.channelId,
+      runId: args.logContext.runId,
+      assistantUserName: args.logContext.assistantUserName,
+      modelId: args.logContext.modelId
+    },
+    {
+      "app.ai.resume_conversation_id": args.conversationId,
+      "app.ai.resume_session_id": args.sessionId,
+      ...attributes
+    },
+    message
+  );
+}
+function addDurationMs(prior, current) {
+  const total = [prior, current].reduce((sum, value) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return sum;
+    }
+    return (sum ?? 0) + Math.max(0, Math.floor(value));
+  }, void 0);
+  return total;
+}
+function isContinuableBoundary(messages) {
+  const lastRole = getPiMessageRole(messages.at(-1));
+  return lastRole === "user" || lastRole === "toolResult";
+}
+function resumableBoundary(messages, fallbackMessages) {
+  const current = trimTrailingAssistantMessages(messages);
+  if (current.length > 0 && isContinuableBoundary(current)) {
+    return current;
+  }
+  return trimTrailingAssistantMessages(fallbackMessages ?? []);
+}
+async function loadTurnSessionRecord(ctx) {
+  const canUseTurnSession = Boolean(ctx.conversationId && ctx.sessionId);
+  const existingSessionRecord = canUseTurnSession && ctx.conversationId && ctx.sessionId ? await getAgentTurnSessionRecord(ctx.conversationId, ctx.sessionId) : void 0;
+  const hasAwaitingResumeRecord = Boolean(
+    existingSessionRecord && existingSessionRecord.state === "awaiting_resume"
+  );
+  return {
+    canUseTurnSession,
+    resumedFromSessionRecord: hasAwaitingResumeRecord,
+    currentSliceId: hasAwaitingResumeRecord ? existingSessionRecord.sliceId : 1,
+    existingSessionRecord
+  };
+}
+async function persistRunningSessionRecord(args) {
+  if (args.messages.length === 0 || !isContinuableBoundary(args.messages)) {
+    return false;
+  }
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: latestSessionRecord?.cumulativeDurationMs,
+      cumulativeUsage: latestSessionRecord?.cumulativeUsage,
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: "running",
+      piMessages: args.messages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
+      } : {}
+    });
+    return true;
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_running_session_record_failed",
+      args,
+      {
+        "app.ai.resume_slice_id": args.sliceId
+      },
+      "Failed to persist running turn session record"
+    );
+    return false;
+  }
+}
+async function persistCompletedSessionRecord(args) {
+  let sliceId = args.sliceId;
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    sliceId = sliceId ?? latestSessionRecord?.sliceId;
+    if (sliceId === void 0) {
+      throw new Error(
+        "Completed session record requires a slice id from the caller or the latest stored record"
+      );
+    }
+    await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestSessionRecord?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestSessionRecord?.cumulativeUsage,
+        args.currentUsage
+      ),
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      ...args.destinationVisibility ? { destinationVisibility: args.destinationVisibility } : {},
+      sessionId: args.sessionId,
+      sliceId,
+      state: "completed",
+      piMessages: args.allMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ?? latestSessionRecord?.loadedSkillNames ? {
+        loadedSkillNames: args.loadedSkillNames ?? latestSessionRecord?.loadedSkillNames
+      } : {},
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
+      } : {}
+    });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_completed_session_record_failed",
+      args,
+      sliceId !== void 0 ? { "app.ai.resume_slice_id": sliceId } : {},
+      "Failed to persist completed turn session record"
+    );
+  }
+}
+async function completeDeliveredTurn(args) {
+  await persistCompletedSessionRecord({
+    channelName: args.channelName,
+    conversationId: args.conversationId,
+    currentDurationMs: args.durationMs,
+    currentUsage: args.usage,
+    destination: args.destination,
+    destinationVisibility: args.destinationVisibility,
+    source: args.source,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    allMessages: args.messages,
+    loadedSkillNames: args.loadedSkillNames,
+    logContext: args.logContext,
+    requester: args.requester,
+    surface: args.surface,
+    turnStartMessageIndex: args.turnStartMessageIndex
+  });
+}
+async function persistAuthPauseSessionRecord(args) {
+  const nextSliceId = args.currentSliceId + 1;
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
+    );
+    if (piMessages.length > 0 && !isContinuableBoundary(piMessages)) {
+      return void 0;
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestSessionRecord?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestSessionRecord?.cumulativeUsage,
+        args.currentUsage
+      ),
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: nextSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      resumeReason: "auth",
+      resumedFromSliceId: args.currentSliceId,
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+    });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_auth_resume_session_record_failed",
+      args,
+      {
+        "app.ai.resume_from_slice_id": args.currentSliceId,
+        "app.ai.resume_next_slice_id": nextSliceId
+      },
+      "Failed to persist auth session record before retry"
+    );
+  }
+  return void 0;
+}
+async function persistTimeoutSessionRecord(args) {
+  const nextSliceId = args.currentSliceId + 1;
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
+    );
+    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
+      return void 0;
+    }
+    const cumulativeDurationMs = addDurationMs(
+      latestSessionRecord?.cumulativeDurationMs,
+      args.currentDurationMs
+    );
+    const cumulativeUsage = addAgentTurnUsage(
+      latestSessionRecord?.cumulativeUsage,
+      args.currentUsage
+    );
+    if (nextSliceId > AGENT_CONTINUE_MAX_SLICES) {
+      return await upsertAgentTurnSessionRecord({
+        ...args.channelName ?? latestSessionRecord?.channelName ? {
+          channelName: args.channelName ?? latestSessionRecord?.channelName
+        } : {},
+        conversationId: args.conversationId,
+        cumulativeDurationMs,
+        cumulativeUsage,
+        ...args.destination ?? latestSessionRecord?.destination ? {
+          destination: args.destination ?? latestSessionRecord?.destination
+        } : {},
+        ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+        sessionId: args.sessionId,
+        sliceId: args.currentSliceId,
+        state: "failed",
+        piMessages,
+        ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+        ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+        resumeReason: "timeout",
+        resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
+        errorMessage: `Agent continuation exceeded slice limit (${AGENT_CONTINUE_MAX_SLICES})`,
+        ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+        ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+      });
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs,
+      cumulativeUsage,
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: nextSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      resumeReason: "timeout",
+      resumedFromSliceId: args.currentSliceId,
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+    });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_continue_session_record_failed",
+      args,
+      {
+        "app.ai.resume_from_slice_id": args.currentSliceId,
+        "app.ai.resume_next_slice_id": nextSliceId
+      },
+      "Failed to persist session record before scheduling agent continuation"
+    );
+    return void 0;
+  }
+}
+async function persistYieldSessionRecord(args) {
+  try {
+    const latestSessionRecord = await getAgentTurnSessionRecord(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = resumableBoundary(
+      args.messages,
+      latestSessionRecord?.piMessages
+    );
+    if (piMessages.length === 0 || !isContinuableBoundary(piMessages)) {
+      return void 0;
+    }
+    return await upsertAgentTurnSessionRecord({
+      ...args.channelName ?? latestSessionRecord?.channelName ? { channelName: args.channelName ?? latestSessionRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      cumulativeDurationMs: addDurationMs(
+        latestSessionRecord?.cumulativeDurationMs,
+        args.currentDurationMs
+      ),
+      cumulativeUsage: addAgentTurnUsage(
+        latestSessionRecord?.cumulativeUsage,
+        args.currentUsage
+      ),
+      ...args.destination ?? latestSessionRecord?.destination ? { destination: args.destination ?? latestSessionRecord?.destination } : {},
+      ...args.source ?? latestSessionRecord?.source ? { source: args.source ?? latestSessionRecord?.source } : {},
+      sessionId: args.sessionId,
+      sliceId: args.currentSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      resumeReason: "yield",
+      resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
+      errorMessage: args.errorMessage,
+      ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+    });
+  } catch (recordError) {
+    logSessionRecordError(
+      recordError,
+      "agent_turn_yield_session_record_failed",
+      args,
+      {
+        "app.ai.resume_slice_id": args.currentSliceId
+      },
+      "Failed to persist cooperative yield session record"
+    );
+    return void 0;
+  }
+}
+
+// src/chat/state/artifacts.ts
+function coerceThreadArtifactsState(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  const raw = value;
+  const artifacts = raw.artifacts ?? {};
+  const listColumnMap = artifacts.listColumnMap ?? {};
+  const recentCanvases = [];
+  if (Array.isArray(artifacts.recentCanvases)) {
+    for (const entry of artifacts.recentCanvases) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const candidate = entry;
+      if (typeof candidate.id !== "string" || candidate.id.trim().length === 0) {
+        continue;
+      }
+      recentCanvases.push({
+        id: candidate.id,
+        title: typeof candidate.title === "string" ? candidate.title : void 0,
+        url: typeof candidate.url === "string" ? candidate.url : void 0,
+        createdAt: typeof candidate.createdAt === "string" ? candidate.createdAt : void 0
+      });
+    }
+  }
+  return {
+    assistantContextChannelId: typeof artifacts.assistantContextChannelId === "string" ? artifacts.assistantContextChannelId : void 0,
+    assistantTitle: typeof artifacts.assistantTitle === "string" ? artifacts.assistantTitle : void 0,
+    assistantTitleSourceMessageId: typeof artifacts.assistantTitleSourceMessageId === "string" ? artifacts.assistantTitleSourceMessageId : void 0,
+    lastCanvasId: typeof artifacts.lastCanvasId === "string" ? artifacts.lastCanvasId : void 0,
+    lastCanvasUrl: typeof artifacts.lastCanvasUrl === "string" ? artifacts.lastCanvasUrl : void 0,
+    recentCanvases,
+    lastListId: typeof artifacts.lastListId === "string" ? artifacts.lastListId : void 0,
+    lastListUrl: typeof artifacts.lastListUrl === "string" ? artifacts.lastListUrl : void 0,
+    listColumnMap: {
+      titleColumnId: typeof listColumnMap.titleColumnId === "string" ? listColumnMap.titleColumnId : void 0,
+      completedColumnId: typeof listColumnMap.completedColumnId === "string" ? listColumnMap.completedColumnId : void 0,
+      assigneeColumnId: typeof listColumnMap.assigneeColumnId === "string" ? listColumnMap.assigneeColumnId : void 0,
+      dueDateColumnId: typeof listColumnMap.dueDateColumnId === "string" ? listColumnMap.dueDateColumnId : void 0
+    },
+    updatedAt: typeof artifacts.updatedAt === "string" ? artifacts.updatedAt : void 0
+  };
+}
+function buildArtifactStatePatch(patch) {
+  return {
+    artifacts: {
+      ...patch,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+
+// src/chat/configuration/validation.ts
+var CONFIG_KEY_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
+var SECRET_KEY_RE = /(?:^|[_.-])(token|secret|password|passphrase|api[-_]?key|private[-_]?key|credential|auth)(?:$|[_.-])/i;
+var SECRET_VALUE_PATTERNS = [
+  /\bBearer\s+[A-Za-z0-9._-]{16,}\b/i,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+  /\b(?:ghp|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/,
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/i,
+  /\bsk-[A-Za-z0-9]{20,}\b/,
+  /\bAIza[0-9A-Za-z\-_]{30,}\b/,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/
+];
+function validateConfigKey(key) {
+  const trimmed = key.trim();
+  if (!trimmed) {
+    return "Configuration key must not be empty";
+  }
+  if (!CONFIG_KEY_RE.test(trimmed)) {
+    return `Invalid configuration key "${key}"; expected dotted lowercase namespace (for example "provider.repo")`;
+  }
+  if (SECRET_KEY_RE.test(trimmed)) {
+    return `Configuration key "${key}" appears to be secret-related and is not allowed`;
+  }
+  return void 0;
+}
+function collectStringValues(value, output, depth = 0) {
+  if (depth > 5) {
+    return;
+  }
+  if (typeof value === "string") {
+    output.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectStringValues(item, output, depth + 1);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, nested] of Object.entries(
+      value
+    )) {
+      output.push(key);
+      collectStringValues(nested, output, depth + 1);
+    }
+  }
+}
+function validateConfigValue(value) {
+  const stringValues = [];
+  collectStringValues(value, stringValues);
+  for (const text of stringValues) {
+    for (const pattern of SECRET_VALUE_PATTERNS) {
+      if (pattern.test(text)) {
+        return "Configuration value appears to contain secret material and is not allowed";
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/chat/configuration/service.ts
+function defaultState() {
+  return {
+    schemaVersion: 1,
+    entries: {}
+  };
+}
+function sanitizeEntry(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const key = toOptionalString(value.key);
+  if (!key) {
+    return void 0;
+  }
+  if (validateConfigKey(key)) {
+    return void 0;
+  }
+  const updatedAt = toOptionalString(value.updatedAt);
+  if (!updatedAt) {
+    return void 0;
+  }
+  if (value.scope !== "channel" && value.scope !== "conversation") {
+    return void 0;
+  }
+  const scope = "conversation";
+  return {
+    key,
+    value: value.value,
+    scope,
+    updatedAt,
+    updatedBy: toOptionalString(value.updatedBy),
+    source: toOptionalString(value.source),
+    expiresAt: toOptionalString(value.expiresAt)
+  };
+}
+function coerceState(raw) {
+  if (!isRecord(raw)) {
+    return defaultState();
+  }
+  const rawConfig = isRecord(raw.configuration) ? raw.configuration : {};
+  const rawEntries = isRecord(rawConfig.entries) ? rawConfig.entries : {};
+  const entries = {};
+  for (const [key, value] of Object.entries(rawEntries)) {
+    const entry = sanitizeEntry(value);
+    if (!entry) {
+      continue;
+    }
+    entries[key] = entry;
+  }
+  return {
+    schemaVersion: 1,
+    entries
+  };
+}
+function createChannelConfigurationService(storage) {
+  const getState = async () => {
+    const loaded = await storage.load();
+    return coerceState(loaded);
+  };
+  const saveState = async (state) => {
+    await storage.save({
+      schemaVersion: 1,
+      entries: state.entries
+    });
+  };
+  const get = async (key) => {
+    const normalizedKey = key.trim();
+    const state = await getState();
+    return state.entries[normalizedKey];
+  };
+  const set = async (input) => {
+    const normalizedKey = input.key.trim();
+    const keyError = validateConfigKey(normalizedKey);
+    if (keyError) {
+      throw new Error(keyError);
+    }
+    const valueError = validateConfigValue(input.value);
+    if (valueError) {
+      throw new Error(valueError);
+    }
+    const state = await getState();
+    const nextEntry = {
+      key: normalizedKey,
+      value: input.value,
+      scope: "conversation",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedBy: toOptionalString(input.updatedBy),
+      source: toOptionalString(input.source),
+      expiresAt: toOptionalString(input.expiresAt)
+    };
+    state.entries[normalizedKey] = nextEntry;
+    await saveState(state);
+    return nextEntry;
+  };
+  const unset = async (key) => {
+    const normalizedKey = key.trim();
+    const state = await getState();
+    if (!state.entries[normalizedKey]) {
+      return false;
+    }
+    delete state.entries[normalizedKey];
+    await saveState(state);
+    return true;
+  };
+  const list = async (options = {}) => {
+    const state = await getState();
+    const prefix = options.prefix?.trim();
+    return Object.values(state.entries).filter((entry) => prefix ? entry.key.startsWith(prefix) : true).sort((a, b) => a.key.localeCompare(b.key));
+  };
+  const resolve = async (key) => {
+    const entry = await get(key);
+    return entry?.value;
+  };
+  const resolveValues = async (options = {}) => {
+    const keys = Array.isArray(options.keys) ? options.keys.map((entry) => entry.trim()).filter((entry) => entry.length > 0) : void 0;
+    const entries = options.prefix ? await list({ prefix: options.prefix }) : await list({});
+    const filtered = keys ? entries.filter((entry) => keys.includes(entry.key)) : entries;
+    const resolved = {};
+    for (const entry of filtered) {
+      resolved[entry.key] = entry.value;
+    }
+    return resolved;
+  };
+  return {
+    get,
+    set,
+    unset,
+    list,
+    resolve,
+    resolveValues
+  };
+}
+
+// src/chat/runtime/thread-state.ts
+function threadStateKey(threadId) {
+  return `thread-state:${threadId}`;
+}
+function channelStateKey(channelId) {
+  return `channel-state:${channelId}`;
+}
+function buildThreadStatePayload(patch) {
+  const payload = {};
+  if (patch.artifacts) {
+    Object.assign(payload, buildArtifactStatePatch(patch.artifacts));
+  }
+  if (patch.conversation) {
+    Object.assign(payload, buildConversationStatePatch(patch.conversation));
+  }
+  if (patch.sandboxId !== void 0) {
+    payload.app_sandbox_id = patch.sandboxId;
+  }
+  if (patch.sandboxDependencyProfileHash !== void 0) {
+    payload.app_sandbox_dependency_profile_hash = patch.sandboxDependencyProfileHash;
+  }
+  return payload;
+}
+function mergeArtifactsState(artifacts, patch) {
+  if (!patch) {
+    return artifacts;
+  }
+  return {
+    ...artifacts,
+    ...patch,
+    listColumnMap: {
+      ...artifacts.listColumnMap,
+      ...patch.listColumnMap
+    }
+  };
+}
+function getPersistedSandboxState(state) {
+  return {
+    sandboxId: toOptionalString(state.app_sandbox_id),
+    sandboxDependencyProfileHash: toOptionalString(
+      state.app_sandbox_dependency_profile_hash
+    )
+  };
+}
+async function persistThreadState(thread, patch) {
+  const payload = buildThreadStatePayload(patch);
+  if (Object.keys(payload).length === 0) {
+    return;
+  }
+  await thread.setState(payload);
+}
+async function getPersistedThreadState(threadId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  return await stateAdapter.get(
+    threadStateKey(threadId)
+  ) ?? {};
+}
+async function getPersistedChannelState(channelId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  return await stateAdapter.get(
+    channelStateKey(channelId)
+  ) ?? {};
+}
+async function persistThreadStateById(threadId, patch) {
+  const payload = buildThreadStatePayload(patch);
+  if (Object.keys(payload).length === 0) {
+    return;
+  }
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const key = threadStateKey(threadId);
+  const existing = await stateAdapter.get(key) ?? {};
+  await stateAdapter.set(
+    key,
+    { ...existing, ...payload },
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+}
+function getChannelConfigurationService(thread) {
+  const channel = thread.channel;
+  return createChannelConfigurationService({
+    load: async () => channel.state,
+    save: async (state) => {
+      await channel.setState({
+        configuration: state
+      });
+    }
+  });
+}
+function getChannelConfigurationServiceById(channelId) {
+  return createChannelConfigurationService({
+    load: async () => await getPersistedChannelState(channelId),
+    save: async (state) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      const key = channelStateKey(channelId);
+      const existing = await stateAdapter.get(key) ?? {};
+      await stateAdapter.set(
+        key,
+        { ...existing, configuration: state },
+        JUNIOR_THREAD_STATE_TTL_MS
+      );
+    }
+  });
+}
+
+// src/chat/services/pending-auth.ts
+var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
+var NON_REQUEST_SKIPPED_REASON_PREFIXES = [
+  "directed_to_other_party:",
+  "side_conversation:"
+];
+function isSkippedNonRequest(reason) {
+  return NON_REQUEST_SKIPPED_REASON_PREFIXES.some(
+    (prefix) => reason?.startsWith(prefix)
+  );
+}
+function canReusePendingAuthLink(args) {
+  const { pendingAuth } = args;
+  if (!pendingAuth) {
+    return false;
+  }
+  return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.requesterId === args.requesterId && pendingAuth.scope === args.scope && pendingAuth.sessionId === args.sessionId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+  const pendingAuth = args.conversation.processing.pendingAuth;
+  if (!pendingAuth) {
+    return void 0;
+  }
+  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.requesterId !== args.requesterId || pendingAuth.scope !== args.scope) {
+    return void 0;
+  }
+  return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+  if (!conversation.processing.pendingAuth) {
+    return;
+  }
+  if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) {
+    return;
+  }
+  conversation.processing.pendingAuth = void 0;
+}
+async function applyPendingAuthUpdate(args) {
+  const previousPendingAuth = args.conversation.processing.pendingAuth;
+  args.conversation.processing.pendingAuth = args.nextPendingAuth;
+  if (previousPendingAuth && previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) {
+    await abandonAgentTurnSessionRecord({
+      conversationId: args.conversationId,
+      sessionId: previousPendingAuth.sessionId,
+      errorMessage: "Abandoned by a newer auth-blocked request in the same conversation."
+    });
+  }
+}
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    if (message.author?.isBot) {
+      continue;
+    }
+    if (isSkippedNonRequest(message.meta?.skippedReason)) {
+      continue;
+    }
+    return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+  }
+  return false;
+}
+
+export {
+  buildDeterministicTurnId,
+  CooperativeTurnYieldError,
+  isCooperativeTurnYieldError,
+  TurnInputCommitLostError,
+  isTurnInputCommitLostError,
+  TurnInputDeferredError,
+  isTurnInputDeferredError,
+  startActiveTurn,
+  markTurnClosed,
+  markTurnCompleted,
+  markTurnFailed,
+  hasAgentTurnUsage,
+  addAgentTurnUsage,
+  loadTurnSessionRecord,
+  persistRunningSessionRecord,
+  persistCompletedSessionRecord,
+  completeDeliveredTurn,
+  persistAuthPauseSessionRecord,
+  persistTimeoutSessionRecord,
+  persistYieldSessionRecord,
+  canReusePendingAuthLink,
+  getConversationPendingAuth,
+  clearPendingAuth,
+  applyPendingAuthUpdate,
+  isPendingAuthLatestRequest,
+  coerceThreadArtifactsState,
+  mergeArtifactsState,
+  getPersistedSandboxState,
+  persistThreadState,
+  getPersistedThreadState,
+  persistThreadStateById,
+  getChannelConfigurationService,
+  getChannelConfigurationServiceById
+};