@sentry/junior 0.88.0 → 0.90.0

package/dist/chunk-AOISHLSF.js

@@ -0,0 +1,747 @@
+import {
+  pluginTaskId,
+  pluginTaskParamsSchema,
+  sendVercelPluginTask
+} from "./chunk-KNFROR7R.js";
+import {
+  clearPendingAuth,
+  markTurnCompleted,
+  mergeArtifactsState
+} from "./chunk-ONFOWI2D.js";
+import {
+  escapeXml,
+  getAgentTurnSessionRecord,
+  getInterruptionMarker
+} from "./chunk-GCWD2VHP.js";
+import {
+  createPluginEmbedder,
+  createPluginModel,
+  getPlugins
+} from "./chunk-DACFZ5CI.js";
+import {
+  createPluginLogger,
+  createPluginState
+} from "./chunk-NW7AXDA5.js";
+import {
+  getStateAdapter
+} from "./chunk-RS6ANWVT.js";
+import {
+  getDb
+} from "./chunk-2S7M37HY.js";
+import {
+  GEN_AI_PROVIDER_NAME,
+  botConfig,
+  getPiMessageRole,
+  isToolResultError,
+  isToolResultMessage,
+  normalizeToolNameFromResult,
+  resolveGatewayModel,
+  stripRuntimeTurnContext
+} from "./chunk-HXL2ZV74.js";
+import {
+  buildTurnFailureResponse,
+  logWarn,
+  setSpanAttributes
+} from "./chunk-ZUK7BL63.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-LFLTJQVR.js";
+
+// src/chat/services/context-budget.ts
+var COMPACTION_TRIGGER_INPUT_RATIO = 0.75;
+var COMPACTION_OUTPUT_RESERVE_RATIO = 0.25;
+var COMPACTION_TARGET_RATIO = 0.8;
+var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
+var FALLBACK_MAX_OUTPUT_TOKENS = 128e3;
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function calculateContextCompactionTriggerTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  const maxTokens = positiveInteger(
+    model.maxTokens,
+    FALLBACK_MAX_OUTPUT_TOKENS
+  );
+  const outputReserve = Math.min(
+    maxTokens,
+    Math.floor(contextWindow * COMPACTION_OUTPUT_RESERVE_RATIO)
+  );
+  const usableInputTokens = Math.max(1, contextWindow - outputReserve);
+  return Math.max(
+    1,
+    Math.floor(usableInputTokens * COMPACTION_TRIGGER_INPUT_RATIO)
+  );
+}
+function calculateContextCompactionTargetTokens(triggerTokens) {
+  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
+}
+function getAgentContextCompactionTriggerTokens() {
+  const model = resolveGatewayModel(botConfig.modelId);
+  return calculateContextCompactionTriggerTokens({
+    contextWindow: botConfig.modelContextWindowTokens ?? model.contextWindow,
+    maxTokens: model.maxTokens
+  });
+}
+function getConversationContextCompactionTriggerTokens() {
+  const model = resolveGatewayModel(botConfig.fastModelId);
+  return calculateContextCompactionTriggerTokens({
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  });
+}
+
+// src/chat/services/conversation-memory.ts
+var CONTEXT_MIN_LIVE_MESSAGES = 12;
+var CONTEXT_COMPACTION_BATCH_SIZE = 24;
+var CONTEXT_MAX_COMPACTIONS = 16;
+var CONTEXT_MAX_MESSAGE_CHARS = 3200;
+var SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function generateConversationId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeConversationText(text) {
+  return text.trim().replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
+}
+function buildImageContextSuffix(message, conversation) {
+  const byFileId = conversation?.vision.byFileId;
+  const imageFileIds = message.meta?.imageFileIds ?? [];
+  if (!byFileId || imageFileIds.length === 0) {
+    return "";
+  }
+  const summaries = imageFileIds.map((fileId) => byFileId[fileId]?.summary?.trim()).filter((summary) => Boolean(summary));
+  if (summaries.length === 0) {
+    return "";
+  }
+  return ` [image context: ${summaries.join(" | ")}]`;
+}
+function renderConversationMessageLine(message, conversation) {
+  const displayName = conversationAuthorDisplayName(message);
+  const markers = [];
+  if (message.meta?.replied === false) {
+    markers.push(
+      `assistant skipped: ${message.meta?.skippedReason ?? "no-reply route"}`
+    );
+  }
+  if (message.meta?.explicitMention) {
+    markers.push("explicit mention");
+  }
+  const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
+  const imageContext = buildImageContextSuffix(message, conversation);
+  return `[${message.role}] ${displayName}: ${message.text}${imageContext}${markerSuffix}`;
+}
+function conversationAuthorDisplayName(message) {
+  const author = message.author;
+  const fullName = authorDisplayField(author?.fullName, author?.userId);
+  const userName = authorDisplayField(author?.userName, author?.userId);
+  return fullName ?? userName ?? (message.role === "assistant" ? botConfig.userName : message.role);
+}
+function authorDisplayField(value, userId) {
+  if (!value || value === userId || SLACK_USER_ID_DISPLAY_PATTERN.test(value)) {
+    return void 0;
+  }
+  return value;
+}
+function updateConversationStats(conversation) {
+  const contextText = buildConversationContext(conversation);
+  conversation.stats.estimatedContextTokens = estimateTextTokens(
+    contextText ?? ""
+  );
+  conversation.stats.totalMessageCount = conversation.messages.length;
+  conversation.stats.updatedAtMs = Date.now();
+}
+function upsertConversationMessage(conversation, message) {
+  const existingIndex = conversation.messages.findIndex(
+    (entry) => entry.id === message.id
+  );
+  if (existingIndex >= 0) {
+    conversation.messages[existingIndex] = {
+      ...conversation.messages[existingIndex],
+      ...message,
+      meta: {
+        ...conversation.messages[existingIndex]?.meta,
+        ...message.meta
+      }
+    };
+    updateConversationStats(conversation);
+    return message.id;
+  }
+  conversation.messages.push(message);
+  updateConversationStats(conversation);
+  return message.id;
+}
+function markConversationMessage(conversation, messageId, patch) {
+  if (!messageId) return;
+  const messageIndex = conversation.messages.findIndex(
+    (entry) => entry.id === messageId
+  );
+  if (messageIndex < 0) return;
+  const current = conversation.messages[messageIndex];
+  conversation.messages[messageIndex] = {
+    ...current,
+    meta: {
+      ...current.meta ?? {},
+      ...patch
+    }
+  };
+  updateConversationStats(conversation);
+}
+function buildConversationContext(conversation, options = {}) {
+  const messages = conversation.messages.filter(
+    (entry) => entry.id !== options.excludeMessageId
+  );
+  if (messages.length === 0 && conversation.compactions.length === 0) {
+    return void 0;
+  }
+  const lines = [];
+  if (conversation.compactions.length > 0) {
+    lines.push("<thread-compactions>");
+    for (const [index, compaction] of conversation.compactions.entries()) {
+      lines.push(
+        `  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageIds.length}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`,
+        compaction.summary,
+        "  </compaction>"
+      );
+    }
+    lines.push("</thread-compactions>");
+  }
+  if (messages.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("<thread-transcript>");
+    for (const [index, message] of messages.entries()) {
+      const author = escapeXml(conversationAuthorDisplayName(message));
+      const actorIdAttr = message.author?.userId ? ` actor_id="${escapeXml(message.author.userId)}"` : "";
+      const ts = new Date(message.createdAtMs).toISOString();
+      const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+      lines.push(
+        `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${actorIdAttr}${slackTsAttr}>`,
+        renderConversationMessageLine(message, conversation),
+        "  </message>"
+      );
+    }
+    lines.push("</thread-transcript>");
+  }
+  return lines.join("\n");
+}
+function pruneCompactions(compactions) {
+  if (compactions.length <= CONTEXT_MAX_COMPACTIONS) {
+    return compactions;
+  }
+  const overflowCount = compactions.length - CONTEXT_MAX_COMPACTIONS + 1;
+  const merged = compactions.slice(0, overflowCount);
+  const mergedSummary = merged.map((entry) => entry.summary).join("\n").slice(0, 3500);
+  const mergedIds = merged.flatMap((entry) => entry.coveredMessageIds).slice(0, 500);
+  const compacted = {
+    id: generateConversationId("compaction"),
+    createdAtMs: Date.now(),
+    summary: mergedSummary,
+    coveredMessageIds: mergedIds
+  };
+  return [compacted, ...compactions.slice(overflowCount)];
+}
+async function summarizeConversationChunk(messages, conversation, context, deps) {
+  const transcript = messages.map((message) => renderConversationMessageLine(message, conversation)).join("\n");
+  try {
+    const result = await deps.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      messages: [
+        {
+          role: "user",
+          content: [
+            "Summarize the following older Slack thread transcript segment for future assistant turns.",
+            "Keep the summary factual and concise. Do not invent details.",
+            "",
+            "Output exactly three XML sections in this order:",
+            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
+            "<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
+            "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
+            "",
+            "Do not output any text outside the three sections.",
+            "",
+            transcript
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId,
+        threadId: context.threadId ?? "",
+        channelId: context.channelId ?? "",
+        requesterId: context.requesterId ?? "",
+        runId: context.runId ?? ""
+      }
+    });
+    const summary = result.text.trim();
+    if (summary.length > 0) {
+      return summary.slice(0, 3500);
+    }
+  } catch (error) {
+    logWarn(
+      "conversation_compaction_summary_failed",
+      {
+        slackThreadId: context.threadId,
+        slackUserId: context.requesterId,
+        slackChannelId: context.channelId,
+        runId: context.runId,
+        assistantUserName: botConfig.userName,
+        modelId: botConfig.fastModelId
+      },
+      {
+        "exception.message": error instanceof Error ? error.message : String(error),
+        "app.compaction_messages_covered": messages.length
+      },
+      "Compaction summarization failed; using fallback summary"
+    );
+  }
+  return transcript.slice(0, 2800);
+}
+async function generateThreadTitleWithDeps(sourceText, deps) {
+  const result = await deps.completeText({
+    modelId: botConfig.fastModelId,
+    temperature: 0,
+    messages: [
+      {
+        role: "user",
+        content: [
+          "Generate a concise 5-8 word Slack conversation title from the first user message below.",
+          "Capture the user's main request.",
+          "Reply with ONLY the title, with no quotes or trailing punctuation.",
+          "",
+          `First user message: ${sourceText.slice(0, 500)}`
+        ].join("\n"),
+        timestamp: Date.now()
+      }
+    ],
+    metadata: {
+      modelId: botConfig.fastModelId
+    }
+  });
+  return result.text.trim().slice(0, 60);
+}
+function getThreadTitleSourceMessage(conversation) {
+  let firstMessage;
+  for (const message of conversation.messages) {
+    if (!isHumanConversationMessage(message)) {
+      continue;
+    }
+    if (!firstMessage) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs < firstMessage.createdAtMs) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) {
+      firstMessage = message;
+    }
+  }
+  return firstMessage;
+}
+async function compactConversationIfNeededWithDeps(conversation, context, deps) {
+  updateConversationStats(conversation);
+  let estimatedTokens = conversation.stats.estimatedContextTokens;
+  setSpanAttributes({
+    "app.context_tokens_estimated": estimatedTokens
+  });
+  const triggerTokens = getConversationContextCompactionTriggerTokens();
+  const targetTokens = calculateContextCompactionTargetTokens(triggerTokens);
+  while (estimatedTokens > triggerTokens && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
+    const compactCount = Math.min(
+      CONTEXT_COMPACTION_BATCH_SIZE,
+      conversation.messages.length - CONTEXT_MIN_LIVE_MESSAGES
+    );
+    if (compactCount <= 0) {
+      break;
+    }
+    const compactedChunk = conversation.messages.slice(0, compactCount);
+    const summary = await summarizeConversationChunk(
+      compactedChunk,
+      conversation,
+      context,
+      deps
+    );
+    conversation.compactions.push({
+      id: generateConversationId("compaction"),
+      createdAtMs: Date.now(),
+      summary,
+      coveredMessageIds: compactedChunk.map((entry) => entry.id)
+    });
+    conversation.compactions = pruneCompactions(conversation.compactions);
+    conversation.messages = conversation.messages.slice(compactCount);
+    conversation.stats.compactedMessageCount += compactCount;
+    updateConversationStats(conversation);
+    estimatedTokens = conversation.stats.estimatedContextTokens;
+    setSpanAttributes({
+      "app.compaction_messages_covered": compactCount,
+      "app.compaction.trigger_tokens": triggerTokens,
+      "app.compaction.target_tokens": targetTokens,
+      "app.context_tokens_estimated": estimatedTokens
+    });
+    if (estimatedTokens <= targetTokens) {
+      break;
+    }
+  }
+}
+function createConversationMemoryService(deps) {
+  return {
+    compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps),
+    generateThreadTitle: async (sourceText) => await generateThreadTitleWithDeps(sourceText, deps)
+  };
+}
+function isHumanConversationMessage(message) {
+  return message.role === "user" && message.author?.isBot !== true;
+}
+function getConversationMessageSlackTs(message) {
+  return parseSlackMessageTs(message.meta?.slackTs);
+}
+
+// src/chat/services/turn-failure-response.ts
+function requireTurnFailureEventId(eventId, eventName) {
+  if (!eventId) {
+    throw new Error(`Sentry did not return an event ID for ${eventName}`);
+  }
+  return eventId;
+}
+function getExecutionFailureReason(reply) {
+  const errorMessage = reply.diagnostics.errorMessage?.trim();
+  if (errorMessage) {
+    return errorMessage;
+  }
+  if (reply.diagnostics.toolErrorCount > 0) {
+    return `${reply.diagnostics.toolErrorCount} tool result error(s)`;
+  }
+  if (reply.diagnostics.assistantMessageCount > 0) {
+    return "assistant returned no text";
+  }
+  return "empty assistant turn";
+}
+function getFailureCapture(reply) {
+  if (reply.diagnostics.outcome === "provider_error") {
+    return {
+      eventName: "agent_turn_provider_error",
+      error: reply.diagnostics.providerError ?? new Error(
+        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
+      ),
+      attributes: {},
+      body: "Agent turn failed with provider error"
+    };
+  }
+  const failureReason = getExecutionFailureReason(reply);
+  return {
+    eventName: "agent_turn_execution_failure",
+    error: new Error(`Agent turn execution failure: ${failureReason}`),
+    attributes: {
+      "app.ai.execution_failure_reason": failureReason
+    },
+    body: "Agent turn completed with execution failure"
+  };
+}
+function getAgentTurnDiagnosticsAttributes(reply) {
+  return {
+    "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+    "gen_ai.operation.name": "invoke_agent",
+    "app.ai.outcome": reply.diagnostics.outcome,
+    "app.ai.assistant_messages": reply.diagnostics.assistantMessageCount,
+    "app.ai.tool_results": reply.diagnostics.toolResultCount,
+    "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
+    "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
+    "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
+    ...reply.diagnostics.thinkingLevel ? {
+      "app.ai.reasoning_effort": reply.diagnostics.thinkingLevel
+    } : {},
+    ...reply.diagnostics.stopReason ? {
+      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
+    } : {},
+    ...reply.diagnostics.errorMessage ? { "exception.message": reply.diagnostics.errorMessage } : {}
+  };
+}
+function finalizeFailedTurnReply(args) {
+  if (args.reply.diagnostics.outcome === "success") {
+    return args.reply;
+  }
+  const capture = getFailureCapture(args.reply);
+  const eventId = requireTurnFailureEventId(
+    args.logException(
+      capture.error,
+      capture.eventName,
+      args.context,
+      {
+        ...getAgentTurnDiagnosticsAttributes(args.reply),
+        ...args.attributes,
+        ...capture.attributes
+      },
+      capture.body
+    ),
+    capture.eventName
+  );
+  const providerPartialText = args.reply.diagnostics.outcome === "provider_error" && args.reply.diagnostics.assistantMessageCount > 0 ? args.reply.text.trim() : "";
+  return {
+    ...args.reply,
+    text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : buildTurnFailureResponse(eventId),
+    deliveryMode: "thread",
+    deliveryPlan: {
+      mode: "thread",
+      postThreadText: true
+    }
+  };
+}
+
+// src/chat/plugins/task-runner.ts
+import { pluginRunContextSchema } from "@sentry/junior-plugin-api";
+var PLUGIN_TASK_LOCK_TTL_MS = 5 * 60 * 1e3;
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function textPart(value) {
+  if (isRecord(value) && value.type === "text" && typeof value.text === "string") {
+    return value.text;
+  }
+  return void 0;
+}
+function messageText(message) {
+  const content = message.content;
+  if (typeof content === "string") {
+    return sanitizeText(content);
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return sanitizeText(content.map(textPart).filter(Boolean).join("\n"));
+}
+function toolResultText(message) {
+  const record = message;
+  const parts = [
+    messageText(message),
+    record.output,
+    record.result,
+    record.stdout,
+    record.stderr,
+    record.toolResult
+  ].filter(
+    (value) => typeof value === "string" && value.length > 0
+  );
+  return sanitizeText(parts.join("\n"));
+}
+function sanitizeText(text) {
+  return text.replace(
+    /<data_base64>[\s\S]*?<\/data_base64>/g,
+    "<data_base64>[omitted]</data_base64>"
+  ).replace(
+    /data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=]+/gi,
+    "[image data omitted]"
+  ).replaceAll("\0", " ").trim();
+}
+function runTranscriptEntry(message) {
+  const role = getPiMessageRole(message);
+  if (role === "user" || role === "assistant") {
+    const text2 = messageText(message);
+    if (!text2) {
+      return void 0;
+    }
+    return { type: "message", role, text: text2 };
+  }
+  if (!isToolResultMessage(message)) {
+    return void 0;
+  }
+  const toolName = normalizeToolNameFromResult(message);
+  if (!toolName) {
+    return void 0;
+  }
+  const text = toolResultText(message);
+  return {
+    type: "toolResult",
+    toolName,
+    isError: isToolResultError(message),
+    ...text ? { text } : {}
+  };
+}
+async function withPluginTaskLock(taskId, callback) {
+  const state = getStateAdapter();
+  await state.connect();
+  const lock = await state.acquireLock(
+    `plugin:task:${taskId}`,
+    PLUGIN_TASK_LOCK_TTL_MS
+  );
+  if (!lock) {
+    throw new Error(`Could not acquire plugin task lock for ${taskId}`);
+  }
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function loadPluginRun(params) {
+  const record = await getAgentTurnSessionRecord(
+    params.conversationId,
+    params.sessionId
+  );
+  if (!record) {
+    throw new Error("Completed plugin task session record is unavailable");
+  }
+  if (record.state !== "completed") {
+    throw new Error("Completed plugin task session record is not completed");
+  }
+  if (!record.source || !record.destination) {
+    throw new Error(
+      "Completed plugin task session record is missing source or destination"
+    );
+  }
+  const sessionMessages = stripRuntimeTurnContext(
+    record.piMessages.slice(record.turnStartMessageIndex ?? 0)
+  );
+  return pluginRunContextSchema.parse({
+    completedAtMs: record.updatedAtMs,
+    conversationId: record.conversationId,
+    destination: record.destination,
+    ...record.requester ? { requester: record.requester } : {},
+    runId: record.sessionId,
+    source: record.source,
+    transcript: sessionMessages.map(runTranscriptEntry).filter((entry) => Boolean(entry))
+  });
+}
+function taskPluginContext(plugin, message, options = {}) {
+  const pluginName = plugin.manifest.name;
+  const sessionParams = pluginTaskParamsSchema.parse(message.params);
+  return {
+    db: getDb(),
+    embedder: createPluginEmbedder(pluginName, {
+      signal: options.signal
+    }),
+    id: pluginTaskId(message),
+    log: createPluginLogger(pluginName),
+    model: createPluginModel(pluginName, plugin.model, {
+      signal: options.signal
+    }),
+    name: message.name,
+    plugin: { name: pluginName },
+    run: {
+      async load() {
+        return await loadPluginRun(sessionParams);
+      }
+    },
+    state: createPluginState(pluginName)
+  };
+}
+function findPluginTask(message) {
+  const plugin = getPlugins().find(
+    (candidate) => candidate.manifest.name === message.plugin
+  );
+  if (!plugin?.tasks || !Object.hasOwn(plugin.tasks, message.name)) {
+    return void 0;
+  }
+  const task = plugin.tasks[message.name];
+  return { plugin, task };
+}
+async function scheduleSessionCompletedPluginTasks(params, options = {}) {
+  const coreParams = pluginTaskParamsSchema.parse(params);
+  const taskRegistrations = getPlugins().flatMap(
+    (plugin) => Object.keys(plugin.tasks ?? {}).map((name) => ({ name, plugin }))
+  );
+  if (taskRegistrations.length === 0) {
+    return;
+  }
+  const record = await getAgentTurnSessionRecord(
+    coreParams.conversationId,
+    coreParams.sessionId
+  );
+  if (!record || record.state !== "completed") {
+    throw new Error("Completed plugin task session record is not ready");
+  }
+  const send = options.send ?? sendVercelPluginTask;
+  const messages = taskRegistrations.map(({ name, plugin }) => ({
+    name,
+    params: coreParams,
+    plugin: plugin.manifest.name
+  }));
+  await Promise.all(
+    messages.map(async (message) => {
+      await send(message);
+    })
+  );
+}
+async function processPluginTask(message, options = {}) {
+  await withPluginTaskLock(pluginTaskId(message), async () => {
+    const resolved = findPluginTask(message);
+    if (!resolved) {
+      throw new Error(
+        `Plugin task "${message.plugin}.${message.name}" is not registered`
+      );
+    }
+    await resolved.task.run(
+      taskPluginContext(resolved.plugin, message, options)
+    );
+  });
+}
+
+// src/chat/runtime/delivered-turn-state.ts
+var NO_VISIBLE_REPLY_CONVERSATION_TEXT = "[no visible reply]";
+function buildDeliveredTurnStatePatch(args) {
+  const conversation = structuredClone(args.conversation);
+  const artifactStatePatch = {
+    ...args.reply.artifactStatePatch ?? {},
+    ...args.artifactStatePatch ?? {}
+  };
+  const artifacts = Object.keys(artifactStatePatch).length > 0 ? mergeArtifactsState(args.artifacts, artifactStatePatch) : void 0;
+  clearPendingAuth(conversation, args.sessionId);
+  const assistantText = normalizeConversationText(args.reply.text) || (args.reply.deliveryPlan?.postThreadText === false ? NO_VISIBLE_REPLY_CONVERSATION_TEXT : "[empty response]");
+  markConversationMessage(conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  upsertConversationMessage(conversation, {
+    id: generateConversationId("assistant"),
+    role: "assistant",
+    text: assistantText,
+    createdAtMs: Date.now(),
+    author: {
+      userName: botConfig.userName,
+      isBot: true
+    },
+    meta: {
+      replied: true
+    }
+  });
+  markTurnCompleted({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId,
+    updateConversationStats
+  });
+  return {
+    artifacts,
+    conversation,
+    sandboxId: args.reply.sandboxId,
+    sandboxDependencyProfileHash: args.reply.sandboxDependencyProfileHash
+  };
+}
+
+export {
+  estimateTextTokens,
+  getAgentContextCompactionTriggerTokens,
+  generateConversationId,
+  normalizeConversationText,
+  updateConversationStats,
+  upsertConversationMessage,
+  markConversationMessage,
+  buildConversationContext,
+  getThreadTitleSourceMessage,
+  createConversationMemoryService,
+  isHumanConversationMessage,
+  getConversationMessageSlackTs,
+  requireTurnFailureEventId,
+  getAgentTurnDiagnosticsAttributes,
+  finalizeFailedTurnReply,
+  scheduleSessionCompletedPluginTasks,
+  processPluginTask,
+  buildDeliveredTurnStatePatch
+};