@sentry/junior 0.192.0 → 0.194.0

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;

package/dist/chat/services/turn-session-routing.d.ts

@@ -5,18 +5,19 @@
  * parent reads through that relation. Later Turns and mailbox wakes use the
  * same Destination so tools stay consistent for the whole Conversation.
  */
-import type { Destination, Source } from "@sentry/junior-plugin-api";
+import type { Destination } from "@sentry/junior-plugin-api";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { Location } from "@/chat/conversations/location";
+import type { SessionSource } from "@/chat/source";
 export interface TurnSessionRouting {
     destination: Destination;
     location?: Location;
     /** Present when the conversation already stores a session source. */
-    source?: Source;
+    source?: SessionSource;
 }
 /** Conversation data with a required Destination and Source. */
 export type RequiredTurnSessionRouting = TurnSessionRouting & {
-    source: Source;
+    source: SessionSource;
 };
 /**
  * Resolve the Conversation Location, Destination, and session Source.

package/dist/chat/slack/{source-link.d.ts → location-url.d.ts}

@@ -4,7 +4,7 @@ export declare function parseSlackTeamDomain(value: unknown): string | undefined
  * Build a direct Slack archive URL for a thread when the workspace domain is
  * known. Omits a link rather than falling back to `app_redirect`.
  */
-export declare function buildSlackSourceUrl(args: {
+export declare function buildSlackLocationUrl(args: {
     channelId: string;
     teamDomain: string;
     threadTs: string;

package/dist/chat/slack/tool-support/context.d.ts

@@ -1,18 +1,15 @@
 import type { ToolRuntimeContext } from "@/chat/tools/types";
-import type { SlackDestination } from "@sentry/junior-plugin-api";
-import type { SlackSource } from "@sentry/junior-plugin-api";
 import type { SlackActor } from "@/chat/actor";
 import { type SlackChannelId, type SlackTeamId } from "@/chat/slack/ids";
 import { type SlackMessageTs } from "@/chat/slack/timestamp";
 export interface SlackToolContext {
-    destination: SlackDestination;
-    source: SlackSource;
     actor?: SlackActor;
     destinationChannelId: SlackChannelId;
+    locationChannelId: SlackChannelId;
+    messageChannelId?: SlackChannelId;
     messageTs?: SlackMessageTs;
-    sourceChannelId: SlackChannelId;
     teamId: SlackTeamId;
     threadTs?: SlackMessageTs;
 }
-/** Resolve Slack-specific tool context from the active source/destination/actor. */
+/** Resolve Slack tool context from the Conversation Location. */
 export declare function getSlackToolContext(context: ToolRuntimeContext): SlackToolContext | undefined;

package/dist/chat/source.d.ts

@@ -1,5 +1,5 @@
 import { type Source } from "@sentry/junior-plugin-api";
-/** Source coordinates reduced to the stable locator for one conversation. */
+/** Legacy provider Source fields stored on a Conversation. */
 export type SessionSource = Extract<Source, {
     kind: "web";
 }> | Extract<Source, {
@@ -8,11 +8,9 @@ export type SessionSource = Extract<Source, {
     kind: "slack";
 }>, "messageTs">;
 /**
- * Normalize a turn Source into the session-stable locator persisted on a
- * conversation. Drops per-message timestamps. Threaded Slack turns keep their
- * thread anchor; channel-level turns (scheduled/event dispatch) keep the
- * channel locator without inventing a threadTs.
+ * Normalize a Turn Source into legacy provider fields stored on a Conversation.
+ * System Sources do not contain a Conversation Location.
  */
 export declare function normalizeSessionSource(value: Source | undefined): SessionSource | undefined;
-/** Parse a serialized Source into the stable locator stored on a conversation. */
+/** Parse a serialized Source into legacy provider fields stored on a Conversation. */
 export declare function parseSessionSource(value: unknown): SessionSource | undefined;

package/dist/chat/task-execution/checkpoint.d.ts

@@ -49,6 +49,8 @@ interface TurnCheckpointWrite {
     source?: Source;
     surface?: AgentTurnSurface;
     turnStartMessageIndex?: number;
+    /** Tool calls charged to this turn; survives history replacement. */
+    cumulativeToolCallCount?: number;
     trailingMessageProvenance?: ConversationMessageProvenance[];
     turnContexts?: PluginTurnContext[];
     durationMs?: number;

package/dist/chat/task-execution/turn-cursor.d.ts

@@ -32,6 +32,8 @@ export interface TurnRecord {
     version: number;
     conversationId: string;
     cumulativeDurationMs: number;
+    /** Tool calls charged to this turn; survives history replacement. */
+    cumulativeToolCallCount?: number;
     cumulativeUsage?: AgentTurnUsage;
     dispatchId?: string;
     dispatchOutcome?: AgentDispatchOutcome;
@@ -86,6 +88,7 @@ export declare function upsertTurnRecord(args: {
     channelName?: string;
     conversationId: string;
     cumulativeDurationMs?: number;
+    cumulativeToolCallCount?: number;
     cumulativeUsage?: AgentTurnUsage;
     destination?: Destination;
     dispatchId?: string;

package/dist/chat/tasks/execution-stats.d.ts

@@ -3,22 +3,34 @@ export declare const TASK_EXECUTION_TYPES: readonly ["scheduled", "event"];
 export declare const TASK_EXECUTION_STATUSES: readonly ["blocked", "completed", "failed"];
 export type TaskExecutionType = (typeof TASK_EXECUTION_TYPES)[number];
 export type TaskExecutionDay = {
+    costUsd: number;
     date: string;
     event: number;
     scheduled: number;
 };
+export type TaskRunWindows = {
+    1: number;
+    7: number;
+    30: number;
+    90: number;
+};
 export type TaskExecutionSummary = {
     lastConversationId?: string;
     lastExecutedAtMs?: number;
-    runsLast7Days: number;
+    runs: TaskRunWindows;
     totalRuns: number;
 };
+/** Empty run windows for tasks with no execution history. */
+export declare function emptyTaskRunWindows(): TaskRunWindows;
 export type TaskExecutionRecord = {
     conversationId?: string;
+    costUsd?: number;
+    durationMs?: number;
     executedAt: string;
     executionId: string;
     status: TaskExecutionStatus;
     title?: string;
+    totalTokens?: number;
 };
 export type TaskRunRecord = TaskExecutionRecord & {
     kind: TaskExecutionType;

package/dist/chat/tools/delete-event-task.d.ts

@@ -1,6 +1,6 @@
 import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
-/** Create the core tool that deletes an event task in this destination. */
+/** Create the core tool that deletes an event task. */
 export declare function createDeleteEventTaskTool(context: ToolRuntimeContext, catalog: ResourceEventCatalog): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("./definition").JsonSchemaObject;
     outputSchema: import("./definition").JsonSchemaObject;

package/dist/chat/tools/types.d.ts

@@ -1,5 +1,5 @@
 import type { FileUpload } from "chat";
-import type { WebSource, ResourceEventSource, Destination, Identity, LocalDestination, LocalSource, PluginEgress, SlackDestination, SlackSource, Source, SystemActor, User } from "@sentry/junior-plugin-api";
+import type { AgentInvocationSource, EventTaskSource, WebSource, ResourceEventSource, Destination, Identity, Location, LocalDestination, LocalSource, PluginDispatchSource, PluginEgress, SlackDestination, SlackSource, Source, ScheduledTaskSource, User } from "@sentry/junior-plugin-api";
 import type { McpToolManager } from "@/chat/mcp/tool-manager";
 import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
 import type { AgentTurnSurface } from "@/chat/task-execution/checkpoint";
@@ -12,6 +12,7 @@ import type { GeneratedArtifactFileRef } from "@/chat/tools/sandbox/file-uploads
 import type { SpawnAgent } from "@/chat/agent/types";
 import type { AttachmentStorage } from "@/chat/attachments/storage";
 import type { Workspace } from "@/chat/workspaces/types";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 interface HandoffControl {
     /** Non-empty catalog of configured targets. */
     profiles: readonly [ModelProfile, ...ModelProfile[]];
@@ -65,7 +66,11 @@ interface BaseToolRuntimeContext {
      */
     conversationId: string;
     /** Location associated with this Conversation. */
+    location?: Location;
+    /** Legacy Location identity used by memory and plugin contexts. */
     locationId?: string;
+    /** Stored Conversation visibility used by tools. */
+    conversationPrivacy?: ConversationPrivacy;
     /** Runtime-owned default outbound destination for this invocation. */
     destination: Destination;
     actor?: Actor;
@@ -99,24 +104,20 @@ interface LocalToolRuntimeContext extends BaseToolRuntimeContext {
     destination: LocalDestination;
     actor?: LocalActor;
     source: LocalSource;
-    slack?: never;
     slackActionToken?: never;
 }
 interface WebToolRuntimeContext extends BaseToolRuntimeContext {
     destination: Destination;
     actor?: WebActor;
     source: WebSource;
-    slack?: never;
     slackActionToken?: never;
 }
-interface ResourceEventToolRuntimeContext extends BaseToolRuntimeContext {
+export type ToolRuntimeContext = LocalToolRuntimeContext | SlackToolRuntimeContext | WebToolRuntimeContext | (BaseToolRuntimeContext & {
     destination: Destination;
-    actor?: SystemActor;
-    source: ResourceEventSource;
-    slack?: never;
+    actor?: Actor;
+    source: AgentInvocationSource | EventTaskSource | PluginDispatchSource | ResourceEventSource | ScheduledTaskSource;
     slackActionToken?: never;
-}
-export type ToolRuntimeContext = LocalToolRuntimeContext | ResourceEventToolRuntimeContext | SlackToolRuntimeContext | WebToolRuntimeContext;
+});
 export interface ToolState {
     getOperationResult: <T>(operationKey: string) => T | undefined;
     setOperationResult: (operationKey: string, result: unknown) => void;

package/dist/chat/tools/update-event-task.d.ts

@@ -1,6 +1,6 @@
 import { type ResourceEventCatalog } from "@/chat/resource-events/catalog";
 import type { ToolRuntimeContext } from "@/chat/tools/types";
-/** Create the core tool that updates an event task in this destination. */
+/** Create the core tool that updates an event task. */
 export declare function createUpdateEventTaskTool(context: ToolRuntimeContext, catalog: ResourceEventCatalog): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
     inputSchema: import("./definition").JsonSchemaObject;
     outputSchema: import("./definition").JsonSchemaObject;

package/dist/chat/usage.d.ts

@@ -34,5 +34,9 @@ export declare const agentTurnUsageSchema: import("zod").ZodObject<{
 export type AgentTurnUsage = Usage;
 /** Return whether any token counter is present on a usage record. */
 export declare function hasAgentTurnUsage(usage: AgentTurnUsage | undefined): usage is AgentTurnUsage;
+/** Estimated total USD cost from one usage record, when any cost field is present. */
+export declare function agentTurnCostUsd(usage: AgentTurnUsage | undefined): number | undefined;
+/** Total token count from one usage record, preferring component counters. */
+export declare function agentTurnTotalTokens(usage: AgentTurnUsage | undefined): number | undefined;
 /** Aggregate token usage across slices without double-counting provider totals. */
 export declare function addAgentTurnUsage(...usages: Array<AgentTurnUsage | undefined>): AgentTurnUsage | undefined;

package/dist/{chunk-YRWGJ5OO.js → chunk-2NL3Y47F.js}

@@ -2,16 +2,16 @@ import {
   coerceThreadConversationState,
   getPersistedThreadState,
   persistThreadStateById
-} from "./chunk-Z4DNJI5F.js";
+} from "./chunk-GY5SEFVL.js";
 import {
   clearPendingAuth,
   markTurnClosed,
   markTurnCompleted
-} from "./chunk-7XO7PTZE.js";
+} from "./chunk-G35QGPO2.js";
 import {
   hydrateConversationMessages,
   markConversationMessage
-} from "./chunk-VF3EDS7P.js";
+} from "./chunk-OEQOAONV.js";
 import {
   buildDeterministicTurnId
 } from "./chunk-DA2KGZZI.js";
@@ -20,13 +20,13 @@ import {
   findProviderError,
   getProviderErrorAttributes,
   getProviderErrorUserMessage
-} from "./chunk-4Z7B5WVV.js";
+} from "./chunk-U76RWMFR.js";
 import {
   parseSlackMessageTs
 } from "./chunk-N7TMSOZH.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-3ADPXQBL.js";
+} from "./chunk-X76JVHQ4.js";
 
 // src/chat/runtime/delivered-turn-state.ts
 function buildDeliveredTurnStatePatch(args) {

package/dist/{chunk-BGLMT6KP.js → chunk-53IEEFFP.js}

@@ -1,12 +1,12 @@
 import {
   ConversationTurnLifecycleService
-} from "./chunk-PXUBRZBU.js";
+} from "./chunk-6H2MKVV5.js";
 import {
   runAgentWithTimeout
-} from "./chunk-SSR6YBWW.js";
+} from "./chunk-ENWIHU54.js";
 import {
   getConversationEventStore
-} from "./chunk-AKR6W7VV.js";
+} from "./chunk-ADEACKAH.js";
 
 // src/chat/runtime/turn-execution.ts
 var AgentRunError = class extends Error {

package/dist/{chunk-PXUBRZBU.js → chunk-6H2MKVV5.js}

@@ -1,6 +1,6 @@
 import {
   getConversationEventStore
-} from "./chunk-AKR6W7VV.js";
+} from "./chunk-ADEACKAH.js";
 
 // src/chat/conversations/turn-lifecycle.ts
 var ConversationTurnLifecycleService = class {

package/dist/{chunk-47JFLZSF.js → chunk-73JEAQRT.js}

@@ -19,23 +19,23 @@ import {
   releaseConversationWork,
   requestAnotherSlice,
   startConversationWork
-} from "./chunk-G4E5WIRL.js";
+} from "./chunk-E53C73ML.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-SZ2O3CGS.js";
+} from "./chunk-NWWDFHXP.js";
 import {
   ConversationQueueMessageRejectedError
 } from "./chunk-JAL3CH4G.js";
 import {
   getChatConfig,
   isProviderRetryError
-} from "./chunk-4Z7B5WVV.js";
+} from "./chunk-U76RWMFR.js";
 import {
   logException,
   logInfo,
   logWarn,
   withLogContext
-} from "./chunk-3ADPXQBL.js";
+} from "./chunk-X76JVHQ4.js";
 
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;

package/dist/{chunk-6LX6KV5C.js → chunk-7ANA7PBB.js}

@@ -1,13 +1,13 @@
 import {
   toOptionalTrimmed
-} from "./chunk-4Z7B5WVV.js";
+} from "./chunk-U76RWMFR.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-FGYWKKTJ.js";
+} from "./chunk-WWXJUURQ.js";
 import {
   setSpanAttributes,
   setSpanStatus
-} from "./chunk-3ADPXQBL.js";
+} from "./chunk-X76JVHQ4.js";
 
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {

package/dist/{chunk-AKR6W7VV.js → chunk-ADEACKAH.js}

@@ -8,7 +8,7 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-IBO4YFFZ.js";
+} from "./chunk-XLWZRHX5.js";
 import {
   conversationEventDataSchema,
   decodeStoredConversationEvent,
@@ -20,7 +20,7 @@ import {
 } from "./chunk-VFUK3X5B.js";
 import {
   getChatConfig
-} from "./chunk-4Z7B5WVV.js";
+} from "./chunk-U76RWMFR.js";
 import {
   parseActorUserId,
   parseSlackChannelReferenceId,
@@ -28,7 +28,7 @@ import {
 } from "./chunk-N7TMSOZH.js";
 import {
   normalizeIdentityEmail
-} from "./chunk-3ADPXQBL.js";
+} from "./chunk-X76JVHQ4.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -271,7 +271,7 @@ function normalizeSessionSource(value) {
       conversationId: value.conversationId
     };
   }
-  if (value.kind === "resource_event") {
+  if (value.kind === "resource_event" || value.kind === "scheduled_task" || value.kind === "event_task" || value.kind === "plugin_dispatch" || value.kind === "agent_invocation") {
     return void 0;
   }
   const threadTs = value.threadTs?.trim();
@@ -450,7 +450,9 @@ function locationForWrite(args) {
 }
 function locationFromRow(value, row, sessionSource) {
   if (value !== void 0 && value !== null) {
-    return locationSchema.parse(value);
+    const location = locationSchema.parse(value);
+    const slackSource2 = !location.threadTs && sessionSource?.kind === "slack" && sessionSource.teamId === location.teamId && sessionSource.channelId === location.channelId ? sessionSource : void 0;
+    return slackSource2?.threadTs ? { ...location, threadTs: slackSource2.threadTs } : location;
   }
   if (!row || row.provider === "local") {
     return void 0;
@@ -1397,76 +1399,84 @@ var SqlConversationEventStore = class {
       (event) => newConversationEventSchema.parse(event)
     );
     if (parsed.length === 0) {
-      return;
+      return [];
     }
-    await withConversationEventLock(this.executor, conversationId, async () => {
-      const existingKeys = parsed.map((event) => event.idempotencyKey).filter((key) => key !== void 0);
-      const persistedKeys = existingKeys.length === 0 ? /* @__PURE__ */ new Set() : new Set(
-        (await this.executor.db().select({ key: juniorConversationEvents.idempotencyKey }).from(juniorConversationEvents).where(
-          and6(
-            eq6(
-              juniorConversationEvents.conversationId,
-              conversationId
-            ),
-            inArray2(
-              juniorConversationEvents.idempotencyKey,
-              existingKeys
+    return withConversationEventLock(
+      this.executor,
+      conversationId,
+      async () => {
+        const existingKeys = parsed.map((event) => event.idempotencyKey).filter((key) => key !== void 0);
+        const persistedKeys = existingKeys.length === 0 ? /* @__PURE__ */ new Set() : new Set(
+          (await this.executor.db().select({ key: juniorConversationEvents.idempotencyKey }).from(juniorConversationEvents).where(
+            and6(
+              eq6(
+                juniorConversationEvents.conversationId,
+                conversationId
+              ),
+              inArray2(
+                juniorConversationEvents.idempotencyKey,
+                existingKeys
+              )
             )
-          )
-        )).flatMap((row) => row.key ? [row.key] : [])
-      );
-      const acceptedKeys = new Set(persistedKeys);
-      const pending = parsed.filter((event) => {
-        if (event.idempotencyKey === void 0) return true;
-        if (acceptedKeys.has(event.idempotencyKey)) return false;
-        acceptedKeys.add(event.idempotencyKey);
-        return true;
-      });
-      if (pending.length === 0) {
-        return;
-      }
-      const newestCreatedAtMs = Math.max(
-        ...pending.map((event) => event.createdAtMs)
-      );
-      await ensureConversationRow(
-        this.executor,
-        conversationId,
-        newestCreatedAtMs,
-        options
-      );
-      const cursor = await this.readCursor(conversationId);
-      const historyVersion = cursor.maxHistoryVersion ?? 0;
-      let seq = cursor.nextSeq;
-      const rows = [];
-      for (const event of pending) {
-        const actorIdentityId = await resolveEventActorIdentityId(
-          this.executor,
-          {
-            conversationId,
-            data: event.data,
-            nowMs: event.createdAtMs
-          }
+          )).flatMap((row) => row.key ? [row.key] : [])
         );
-        rows.push(
-          insertFromEvent(
-            conversationId,
-            seq++,
-            historyVersion,
-            event,
-            actorIdentityId
-          )
+        const acceptedKeys = new Set(persistedKeys);
+        const pending = parsed.filter((event) => {
+          if (event.idempotencyKey === void 0) return true;
+          if (acceptedKeys.has(event.idempotencyKey)) return false;
+          acceptedKeys.add(event.idempotencyKey);
+          return true;
+        });
+        if (pending.length === 0) {
+          return [];
+        }
+        const newestCreatedAtMs = Math.max(
+          ...pending.map((event) => event.createdAtMs)
         );
-        if (actorIdentityId) {
-          await recordConversationParticipant(this.executor, {
-            actorIdentityId,
-            conversationId,
-            atMs: event.createdAtMs,
-            restoreArchive: eventUnarchivesConversation(event.data)
-          });
+        await ensureConversationRow(
+          this.executor,
+          conversationId,
+          newestCreatedAtMs,
+          options
+        );
+        const cursor = await this.readCursor(conversationId);
+        const historyVersion = cursor.maxHistoryVersion ?? 0;
+        let seq = cursor.nextSeq;
+        const rows = [];
+        for (const event of pending) {
+          const actorIdentityId = await resolveEventActorIdentityId(
+            this.executor,
+            {
+              conversationId,
+              data: event.data,
+              nowMs: event.createdAtMs
+            }
+          );
+          rows.push(
+            insertFromEvent(
+              conversationId,
+              seq++,
+              historyVersion,
+              event,
+              actorIdentityId
+            )
+          );
+          if (actorIdentityId) {
+            await recordConversationParticipant(this.executor, {
+              actorIdentityId,
+              conversationId,
+              atMs: event.createdAtMs,
+              restoreArchive: eventUnarchivesConversation(event.data)
+            });
+          }
         }
+        await this.executor.db().insert(juniorConversationEvents).values(rows);
+        return rows.map((row) => ({
+          seq: row.seq,
+          historyVersion: row.historyVersion
+        }));
       }
-      await this.executor.db().insert(juniorConversationEvents).values(rows);
-    });
+    );
   }
   async replaceHistory(conversationId, replacement) {
     const parsed = historyReplacementSchema.parse(replacement);
@@ -1484,6 +1494,9 @@ var SqlConversationEventStore = class {
       );
     });
   }
+  async loadCurrentHistoryVersion(conversationId) {
+    return (await this.readCursor(conversationId)).maxHistoryVersion ?? 0;
+  }
   async loadCurrentHistory(conversationId) {
     const cursor = await this.readCursor(conversationId);
     if (cursor.maxHistoryVersion === null) {

package/dist/{chunk-YE6DVM43.js → chunk-AWZS5SVX.js}

@@ -1,32 +1,32 @@
 import {
   resolveBaseUrl
-} from "./chunk-SSR6YBWW.js";
+} from "./chunk-ENWIHU54.js";
 import {
   createPluginLogger,
   getPlugins,
   getSlackClient,
   withSlackRetries
-} from "./chunk-BUTAWPUV.js";
+} from "./chunk-CCTYK5RH.js";
 import {
   getDb,
   parseDestination
-} from "./chunk-AKR6W7VV.js";
+} from "./chunk-ADEACKAH.js";
 import {
   sleep
-} from "./chunk-6LX6KV5C.js";
+} from "./chunk-7ANA7PBB.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-LRTEMMCZ.js";
+} from "./chunk-V4HXV5MY.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-FGYWKKTJ.js";
+} from "./chunk-WWXJUURQ.js";
 import {
   fetchWithBoundedOAuthErrorBodies
-} from "./chunk-6FCKJDKS.js";
+} from "./chunk-S7GX44BU.js";
 import {
   isRecord
-} from "./chunk-3ADPXQBL.js";
+} from "./chunk-X76JVHQ4.js";
 
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {