@sentry/junior 0.193.0 → 0.195.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-42N6CDWF.js";
+} from "./chunk-HE5PZAPS.js";
 import {
   bindSpawnAgent
-} from "./chunk-THFNL3TL.js";
+} from "./chunk-QHJZSYKY.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   resolveAgentInvocationId
-} from "./chunk-AZVDODSP.js";
+} from "./chunk-N67T4VY3.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -37,12 +37,12 @@ import {
   startProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-5E5SLAVD.js";
+} from "./chunk-7UED4D5T.js";
 import "./chunk-FA6POGLH.js";
 import {
   AgentRunError,
   executeTurn
-} from "./chunk-DVU734PI.js";
+} from "./chunk-CE2P6TOV.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -53,7 +53,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-GTXQHZ2O.js";
+} from "./chunk-KUQRWV53.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -73,11 +73,11 @@ import {
   processPluginTask,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-4UA5C7AM.js";
+} from "./chunk-BJZML4RT.js";
 import {
   ConversationTurnLifecycleService,
   getTurnLifecycle
-} from "./chunk-WH5VV2RW.js";
+} from "./chunk-7PQMTME5.js";
 import {
   coerceThreadConversationState,
   getLocationConfigurationService,
@@ -86,7 +86,7 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-S5HS6WRH.js";
+} from "./chunk-FE3Y4KES.js";
 import {
   GET,
   appendAndEnqueueWebMessage,
@@ -101,24 +101,24 @@ import {
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   webActorFromEmail
-} from "./chunk-LG7Q4OW4.js";
+} from "./chunk-PYTRZZ4V.js";
 import {
   createWebAuthorization,
   deleteWebAuthorization
-} from "./chunk-THYNA2QN.js";
+} from "./chunk-5HNXLP4W.js";
 import {
   recordTaskExecution
-} from "./chunk-GUMBIDDL.js";
+} from "./chunk-5NR7N567.js";
 import "./chunk-RC745GGZ.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-N6Q2PNSI.js";
+} from "./chunk-6GGDBXXP.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-GUKGU6R7.js";
+} from "./chunk-3VWIZVK7.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -129,6 +129,7 @@ import {
   RESOURCE_EVENT_MESSAGE_AUTHOR,
   RESOURCE_EVENT_SYSTEM_ACTOR,
   SANDBOX_EGRESS_PROXY_PATH,
+  admitAutomatedTurn,
   buildSteeringPiMessage,
   clearSandboxEgressSignals,
   consumeSandboxEgressAuthRequiredSignal,
@@ -144,11 +145,14 @@ import {
   latestReportedProgress,
   listThreadReplies,
   logScheduledTaskRunSkipped,
+  maybePostAutomatedTurnLimitNotice,
   normalizeSandboxEgressTracePropagationDomains,
   parseSandboxEgressCredentialToken,
+  postAutomatedTurnLimitNoticeForDestination,
   processWorkspaceSnapshotJob,
   publicArtifactHeaders,
   readPublicArtifact,
+  recordFinishedTurnForAutomatedLimit,
   renderAttachmentText,
   renderBlockText,
   renderTaskInput,
@@ -158,11 +162,11 @@ import {
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
   unpublishedArtifactHeaders
-} from "./chunk-PYBFVK6K.js";
+} from "./chunk-FEZIEEOP.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-LXRTHE43.js";
+} from "./chunk-JBSCMOLR.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
@@ -170,14 +174,14 @@ import {
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-D4XQZOHB.js";
+} from "./chunk-OQHO62VA.js";
 import {
   RetryableDeliveryError,
   createAgentRunner,
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-COCVPDWX.js";
+} from "./chunk-R5OHONYU.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -193,11 +197,12 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-K47OVEO4.js";
+} from "./chunk-VYDIA2UL.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
   buildConversationContext,
+  buildTurnErrorResponse,
   commitAcceptedReply,
   commitMessages,
   completeTurnRecord,
@@ -229,7 +234,7 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-ZFPEPWOO.js";
+} from "./chunk-RZ3PBNDV.js";
 import {
   getExperimentalFeatures,
   isExperimentalFeatureEnabled,
@@ -249,10 +254,10 @@ import {
   scheduledRunId,
   scheduledRunSchema,
   withScheduledTaskLock
-} from "./chunk-BFP3ZKG6.js";
+} from "./chunk-DTYOEHUP.js";
 import {
   parseSlackThreadId
-} from "./chunk-HMBTX5RK.js";
+} from "./chunk-6TRQLG3D.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -267,16 +272,16 @@ import {
   removeActiveConversation,
   requestConversationWork,
   stopConversationWork
-} from "./chunk-5LEVZYXF.js";
+} from "./chunk-QKHZF2LH.js";
 import {
   buildDeterministicAssistantMessageId,
   buildDeterministicTurnId
 } from "./chunk-DA2KGZZI.js";
-import "./chunk-D5YQPCEG.js";
+import "./chunk-R5BGW4WR.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-IBXXTO3J.js";
+} from "./chunk-L62JVQPL.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -285,7 +290,7 @@ import {
 } from "./chunk-X6GDDWQH.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-IQCL5JGL.js";
+} from "./chunk-I4RH3KLJ.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
@@ -321,7 +326,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-FQ5HFSFR.js";
+} from "./chunk-PFQRZ4IB.js";
 import "./chunk-3Y47VMHV.js";
 import {
   createSlackDestination,
@@ -333,7 +338,7 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-2CYWEVOP.js";
+} from "./chunk-KQ3GZGBK.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -341,13 +346,13 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-5S6AQFNG.js";
-import "./chunk-KWXZMHJS.js";
+} from "./chunk-FPQPYJEG.js";
+import "./chunk-LM7UE523.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-IOUUS6H4.js";
+} from "./chunk-7MYXH5LA.js";
 import {
   instructionProvenanceFor
 } from "./chunk-GFBR4S3Q.js";
@@ -369,17 +374,17 @@ import {
   isProviderRetryError,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-WJJDQLVL.js";
+} from "./chunk-LMYRF6HX.js";
 import {
   defaultModelId,
   modelIdForProfile
 } from "./chunk-D4YV5TDV.js";
-import "./chunk-OICYQPKP.js";
-import "./chunk-3YZ2Q6AW.js";
+import "./chunk-KBPWC7NU.js";
+import "./chunk-RQO67SAO.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-DXFUYLHX.js";
-import "./chunk-QWY4KI2V.js";
+} from "./chunk-RKA22BQP.js";
+import "./chunk-X3PBQ4BK.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -415,13 +420,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-QY2IU47O.js";
+} from "./chunk-HUQOXMDG.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-QDU5MW2R.js";
+} from "./chunk-C4NY6L7S.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -5017,7 +5022,9 @@ function createSlackTurnRuntime(deps) {
   };
   const postFallbackErrorReplyWithLogging = async (args) => {
     try {
-      await args.thread.post(buildTurnFailureResponse(args.eventId));
+      await args.thread.post(
+        buildTurnErrorResponse(args.error, args.eventId)
+      );
     } catch (postError) {
       logException(postError, args.postFailureEventName, {
         "app.slack.reply_stage": "error_fallback_post",
@@ -5319,6 +5326,7 @@ function createSlackTurnRuntime(deps) {
         await postFallbackErrorReplyWithLogging({
           thread,
           eventId,
+          error: failureCause,
           postFailureEventName: "mention.handler.failure_reply_post.failed"
         });
         if (lifecycleError) throw lifecycleError;
@@ -5607,6 +5615,7 @@ function createSlackTurnRuntime(deps) {
         await postFallbackErrorReplyWithLogging({
           thread,
           eventId,
+          error: failureCause,
           postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
         });
         if (lifecycleError) throw lifecycleError;
@@ -7246,6 +7255,21 @@ function createSlackTurn(deps) {
                 })
               );
               await persistThreadRuntimeStateWithRetry(thread, completedState);
+              const automatedTurnLimit = await recordFinishedTurnForAutomatedLimit(
+                {
+                  conversationId,
+                  destination,
+                  maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                  source
+                }
+              );
+              await maybePostAutomatedTurnLimitNotice({
+                conversationId,
+                destination,
+                maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                threadTs,
+                update: automatedTurnLimit
+              });
             } catch (saveError) {
               saveFailed = true;
               saveFailureEventId = logException(
@@ -9136,6 +9160,19 @@ function createConversationTurnWorker(agentRunner, deliverMessage) {
                   surface
                 });
               }
+              const automatedTurnLimit = await recordFinishedTurnForAutomatedLimit({
+                conversationId: context.conversationId,
+                destination,
+                maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                source
+              });
+              await maybePostAutomatedTurnLimitNotice({
+                conversationId: context.conversationId,
+                destination,
+                maxTurns: botConfig.maxConsecutiveAutomatedTurns,
+                threadTs: conversationLocation?.provider === "slack" ? conversationLocation.threadTs : void 0,
+                update: automatedTurnLimit
+              });
               completedSuccessfully = reply.diagnostics.outcome === "success";
               return completedSuccessfully ? {
                 outcome: assistantMessageDelivered ? "success" : "no_reply"
@@ -9518,8 +9555,40 @@ async function ingestEventTasks(input, options) {
   const tasks = await findMatchingEventTasks(db, event, options.teamId);
   let dispatched = 0;
   const errors = [];
+  const maxTurns = botConfig.maxConsecutiveAutomatedTurns;
+  const noticedDestinations = /* @__PURE__ */ new Set();
   for (const task of tasks) {
     try {
+      const decision = await admitAutomatedTurn({
+        maxTurns,
+        nowMs,
+        scope: { kind: "destination", destination: task.destination }
+      });
+      if (decision.status === "paused") {
+        const destinationId = `${task.destination.teamId}:${task.destination.channelId}`;
+        logInfo("event_tasks.automated_turn_limit.paused", {
+          "app.automated_turn_limit.consecutive": decision.consecutiveAutomatedTurns,
+          "app.automated_turn_limit.max": maxTurns,
+          "app.event_task.id": task.id,
+          "app.resource_event.event_type": event.eventType,
+          "app.resource_event.namespace": event.namespace,
+          "app.slack.channel_id": task.destination.channelId,
+          "app.slack.team_id": task.destination.teamId
+        });
+        if (decision.shouldPostNotice && !noticedDestinations.has(destinationId)) {
+          const posted = await postAutomatedTurnLimitNoticeForDestination({
+            destination: task.destination,
+            maxTurns,
+            nowMs,
+            resumeIn: "channel",
+            scope: { kind: "destination", destination: task.destination }
+          });
+          if (posted) {
+            noticedDestinations.add(destinationId);
+          }
+        }
+        continue;
+      }
       const idempotencyKey = eventTaskDispatchKey(
         task.id,
         event.namespace,

package/dist/{catalog-runtime-NAD44W5K.js → catalog-runtime-6E6SGRZK.js}

@@ -1,14 +1,14 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-DXFUYLHX.js";
-import "./chunk-QWY4KI2V.js";
+} from "./chunk-RKA22BQP.js";
+import "./chunk-X3PBQ4BK.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-QY2IU47O.js";
+import "./chunk-HUQOXMDG.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-QDU5MW2R.js";
+import "./chunk-C4NY6L7S.js";
 export {
   pluginCatalogRuntime
 };

package/dist/chat/agent/resume.d.ts

@@ -38,6 +38,8 @@ export declare function createResumeState(args: ResumeStateArgs): {
     readonly timedOut: boolean;
     setTurnStartMessageIndex(index: number | undefined): void;
     setBeforeMessageCount(count: number): void;
+    /** Admit one tool call against the durable turn total, or throw the limit. */
+    admitToolCall(): void;
     setTurnContexts(contexts: PluginTurnContext[]): void;
     /** Use an already committed boundary as the resume baseline. */
     adoptCommittedBoundary(messages: PiMessage[]): void;

package/dist/chat/config.d.ts

@@ -21,6 +21,8 @@ export interface BotConfig {
     reasoningLevel?: TurnReasoningLevel;
     visionModelId?: string;
     maxSlicesPerTurn: number;
+    maxToolCallsPerTurn: number;
+    maxConsecutiveAutomatedTurns: number;
     turnTimeoutMs: number;
     userName: string;
     webSearchModelId: string;

package/dist/chat/conversations/history.d.ts

@@ -1124,12 +1124,12 @@ export interface ConversationEventPage {
 /** Persist and read the canonical per-conversation event log. */
 export interface ConversationEventStore {
     /**
-     * Append events atomically, optionally preserving conversation activity.
+     * Append events atomically and return each event's sequence and history version.
      * Archive clears only for human user activity, not every non-preserve write.
      */
     append(conversationId: string, events: NewConversationEvent[], options?: {
         activity?: "preserve";
-    }): Promise<void>;
+    }): Promise<Array<Pick<ConversationEvent, "seq" | "historyVersion">>>;
     /** Replace active model history with a compaction or handoff event. */
     replaceHistory(conversationId: string, replacement: HistoryReplacement): Promise<void>;
     /** One event selected by its retry-stable key across history versions. */
@@ -1138,6 +1138,8 @@ export interface ConversationEventStore {
     loadLatestStructuredEvent(conversationId: string, namespace: string, name: string): Promise<ConversationEvent | undefined>;
     /** Latest durable instruction across history versions. */
     loadLatestInstruction(conversationId: string): Promise<ConversationEvent | undefined>;
+    /** Current model-history version, or zero when no event exists. */
+    loadCurrentHistoryVersion(conversationId: string): Promise<number>;
     /** Events of the current history version in `seq` order. */
     loadCurrentHistory(conversationId: string): Promise<ConversationEvent[]>;
     /** Events in the history version containing `seq`, when it exists. */

package/dist/chat/event-tasks/store.d.ts

@@ -1,24 +1,34 @@
 import { type ResourceEvent, type User } from "@sentry/junior-plugin-api";
 import type { JuniorDatabase } from "@/db/db";
+import { type EventTaskStatus } from "@/db/schema/event-tasks";
 import { type EventTask } from "./types";
-/** Read one event task by id. */
-export declare function getEventTask(db: JuniorDatabase, id: string): Promise<EventTask | undefined>;
-/** Create one retry-stable event task or return its existing record. */
-export declare function createEventTask(db: JuniorDatabase, task: EventTask): Promise<EventTask>;
-/** Replace an existing event task. */
-export declare function saveEventTask(db: JuniorDatabase, task: EventTask): Promise<EventTask | undefined>;
-/** Delete one existing event task. */
-export declare function deleteEventTask(db: JuniorDatabase, id: string): Promise<EventTask | undefined>;
-/** List event tasks in one Slack workspace. */
-export declare function listEventTasksForTeam(db: JuniorDatabase, teamId: string): Promise<EventTask[]>;
+/** Live event task plus retained SQL status for history after delete. */
+export type StoredEventTask = EventTask & {
+    status: EventTaskStatus;
+};
+/** Read one event task by id, including deleted rows when present. */
+export declare function getEventTask(db: JuniorDatabase, id: string): Promise<StoredEventTask | undefined>;
+/** Create one retry-stable event task, or revive a deleted row with the new payload. */
+export declare function createEventTask(db: JuniorDatabase, task: EventTask): Promise<StoredEventTask>;
+/** Replace an existing non-deleted event task. */
+export declare function saveEventTask(db: JuniorDatabase, task: EventTask): Promise<StoredEventTask | undefined>;
+/** Mark one existing event task deleted while retaining the row for history. */
+export declare function deleteEventTask(db: JuniorDatabase, id: string): Promise<StoredEventTask | undefined>;
+/** List live event tasks in one Slack workspace. */
+export declare function listEventTasksForTeam(db: JuniorDatabase, teamId: string): Promise<StoredEventTask[]>;
 /** Return whether one event task was created by a viewer-linked Slack identity. */
 export declare function eventTaskBelongsToUser(task: EventTask, user: User): boolean;
-/** List a bounded newest-first page of event tasks created by one user. */
-export declare function listEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<EventTask[]>;
-/** List event tasks whose current Slack destination is public. */
-export declare function listPublicEventTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<EventTask[]>;
+/** List a bounded newest-first page of live event tasks created by one user. */
+export declare function listEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<StoredEventTask[]>;
 /**
- * Collect match keys from event tasks for these identifiers and event types.
+ * List deleted event tasks created by one user, newest first.
+ * Used only to keep historical runs after the live task list drops the row.
+ */
+export declare function listDeletedEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<StoredEventTask[]>;
+/** List live event tasks whose current Slack destination is public. */
+export declare function listPublicEventTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<StoredEventTask[]>;
+/**
+ * Collect match keys from live event tasks for these identifiers and event types.
  * Does not evaluate match values — only reports keys that filters use.
  */
 export declare function collectEventTaskMatchKeys(db: JuniorDatabase, input: {
@@ -27,5 +37,5 @@ export declare function collectEventTaskMatchKeys(db: JuniorDatabase, input: {
     namespace: string;
     teamId: string;
 }): Promise<string[]>;
-/** Find every task matching one normalized resource event. */
-export declare function findMatchingEventTasks(db: JuniorDatabase, event: ResourceEvent, teamId: string): Promise<EventTask[]>;
+/** Find every live task matching one normalized resource event. */
+export declare function findMatchingEventTasks(db: JuniorDatabase, event: ResourceEvent, teamId: string): Promise<StoredEventTask[]>;

package/dist/chat/resource-events/notification.d.ts

@@ -43,7 +43,8 @@ export declare function createResourceEventInboundMessage(input: {
  * Enqueue a resource event as normal conversation mailbox input.
  *
  * The watch only names the conversation. Destination stays on the conversation
- * and is applied when the worker runs.
+ * and is applied when the worker runs. After too many automated Turns with no
+ * user Turn, later wakes stay quiet until a user message clears the pause.
  */
 export declare function enqueueResourceEventNotification(args: {
     event: ResourceEventNotification;

package/dist/chat/services/automated-turn-limit.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Stops event wakes after too many automated Turns with no user Turn.
+ *
+ * Resource-event watches count on the Conversation. Event tasks and other
+ * agent dispatches count on the Slack Destination. A finished user Turn clears
+ * every scope that Turn can name.
+ */
+import type { Destination, Source } from "@sentry/junior-plugin-api";
+import type { StateAdapter } from "chat";
+import { z } from "zod";
+/** Stored consecutive-turn limit for one Conversation or Destination. */
+declare const automatedTurnLimitStateSchema: z.ZodObject<{
+    consecutiveAutomatedTurns: z.ZodNumber;
+    noticePostedAtMs: z.ZodOptional<z.ZodNumber>;
+    paused: z.ZodBoolean;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+export type AutomatedTurnLimitState = z.output<typeof automatedTurnLimitStateSchema>;
+export type AutomatedTurnLimitScope = {
+    kind: "conversation";
+    conversationId: string;
+} | {
+    kind: "destination";
+    destination: Destination;
+};
+export type AutomatedTurnLimitDecision = {
+    status: "allow";
+    consecutiveAutomatedTurns: number;
+} | {
+    status: "paused";
+    consecutiveAutomatedTurns: number;
+    shouldPostNotice: boolean;
+};
+export type AutomatedTurnLimitUpdate = {
+    consecutiveAutomatedTurns: number;
+    paused: boolean;
+    shouldPostNotice: boolean;
+    /** Where the pause notice should tell the user to reply. */
+    resumeIn: "thread" | "channel";
+};
+/** True when this Source starts an automated Turn rather than a user Turn. */
+export declare function isAutomatedTurnSource(source: Source | undefined): boolean;
+/**
+ * Scope that counts automated Turns for this Source.
+ * Resource-event watches stay on the Conversation. Dispatches use Destination.
+ */
+export declare function automatedTurnLimitScopeForSource(args: {
+    conversationId: string;
+    destination?: Destination;
+    source?: Source;
+}): AutomatedTurnLimitScope | undefined;
+/** Plain notice when automatic updates stop until the user replies. */
+export declare function buildAutomatedTurnLimitResponse(args: {
+    maxTurns: number;
+    resumeIn?: "thread" | "channel";
+}): string;
+/** Read the current consecutive-turn limit for one scope. */
+export declare function getAutomatedTurnLimitState(args: {
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitState>;
+/**
+ * Allow one automated wake, or refuse once the consecutive-turn limit is full.
+ * If a prior pause never posted its notice, claim the notice slot so one caller
+ * posts it. Clear the claim if that post fails or is skipped.
+ */
+export declare function admitAutomatedTurn(args: {
+    maxTurns: number;
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitDecision>;
+/** Count one finished automated Turn toward the consecutive-turn limit. */
+export declare function countAutomatedTurn(args: {
+    maxTurns: number;
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitUpdate>;
+/**
+ * Drop a failed notice claim so a later paused wake can post the notice.
+ * Keeps the pause and consecutive count.
+ */
+export declare function clearAutomatedTurnLimitNoticeClaim(args: {
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<void>;
+/** Clear the consecutive automated-turn count after a user-owned Turn. */
+export declare function resetAutomatedTurnLimit(args: {
+    nowMs?: number;
+    scope: AutomatedTurnLimitScope;
+    state?: StateAdapter;
+}): Promise<void>;
+/**
+ * Update consecutive automated-turn limits after one finished Turn.
+ *
+ * Automated Turns count one matching scope. User Turns clear Conversation and
+ * Destination scopes so later event wakes can run again.
+ */
+export declare function recordFinishedTurnForAutomatedLimit(args: {
+    conversationId: string;
+    destination?: Destination;
+    maxTurns: number;
+    nowMs?: number;
+    source?: Source;
+    state?: StateAdapter;
+}): Promise<AutomatedTurnLimitUpdate | undefined>;
+export {};

package/dist/chat/services/turn-limit.d.ts

@@ -1,6 +1,16 @@
-/** Terminal failure raised when one agent turn exhausts its slice budget. */
+/** Terminal failure when one turn uses too many execution slices. */
 export declare class TurnSliceLimitExceededError extends Error {
     constructor(maxSlices: number);
 }
+/** Terminal failure when one turn uses too many tool calls. */
+export declare class TurnToolCallLimitExceededError extends Error {
+    constructor(maxToolCalls: number);
+}
+/** True when a turn hit a hard execution limit, including one Error.cause wrap. */
+export declare function isTurnExecutionLimitExceededError(error: unknown): boolean;
+/** Stop the turn when its tool-call count is past the limit. */
+export declare function assertTurnToolCallLimit(toolCallCount: number, maxToolCalls: number): void;
 /** Explain a terminal turn execution limit with actionable recovery guidance. */
 export declare function buildTurnLimitResponse(eventId: string): string;
+/** User-facing reply for a thrown turn error. */
+export declare function buildTurnErrorResponse(error: unknown, eventId: string): string;