@sentry/junior 0.186.0 → 0.188.0

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

@@ -1,11 +1,6 @@
-/**
- * Public agent-run launch contract.
- *
- * Providers build one flat `AgentRun` and call `AgentRunner.run`. Delivery and
- * durability are capabilities that affect the run. `onEvent` is best-effort UI
- * only. Stable composition binds stream, spawn, and tracing outside this type.
- */
+/** Input for one Run through Junior's agent. */
 import type { Destination, ReplyAttribution, Source, SystemActor } from "@sentry/junior-plugin-api";
+import type { Location } from "@/chat/conversations/location";
 import type { LocationConfigurationService } from "@/chat/configuration/types";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { CredentialContext } from "@/chat/credentials/context";
@@ -38,7 +33,8 @@ export type AgentInstructionActor = {
     authorName?: string;
     /**
      * Slack message ts for the instruction when known.
-     * TODO: generalize to a provider-neutral message id once prompt attrs are neutral.
+     * TODO(dcramer): Use a provider-neutral message id after prompt attributes no
+     * longer require the Slack timestamp.
      */
     slackTs?: string;
 };
@@ -106,7 +102,12 @@ export type AgentRunState = {
  * The runner must commit the preceding agent boundary before invoking this
  * port; the accepted reply transaction appends only this message.
  */
-export type AgentDelivery = (message: AssistantMessage) => void | Promise<void>;
+export type Delivery = {
+    /** Location where this capability can send output, when outside Junior. */
+    location?: Location;
+    /** Send one accepted assistant message. */
+    send(message: AssistantMessage): void | Promise<void>;
+};
 /** Resume the agent turn after a transient or ambiguous delivery failure. */
 export declare class RetryableDeliveryError extends Error {
     constructor(cause: unknown);
@@ -153,7 +154,7 @@ export type AgentEnvironment = {
     };
 };
 /**
- * One provider-launched agent-run slice.
+ * One bounded attempt to advance a Turn.
  *
  * Build identity, instruction, history, delivery, and durability here. Bind
  * stable model/stream composition when creating the runner, not on each run.
@@ -178,14 +179,12 @@ export type AgentRun = {
     credentialContext?: CredentialContext;
     source: Source;
     destination: Destination;
-    /** When true, also publish assistant output to the conversation destination. */
     publishExternally?: boolean;
-    /** Confirmed visibility of the destination where this run is delivered. */
     destinationVisibility?: ConversationPrivacy;
     surface?: AgentTurnSurface;
     dispatch?: AgentDispatch;
     /**
-     * TODO: Move ephemeral Slack credentials and conversation labels into
+     * TODO(dcramer): Move ephemeral Slack credentials and conversation labels into
      * provider-owned tool/prompt context so the shared run edge stays neutral.
      */
     slackConversation?: SlackConversationContext;
@@ -197,9 +196,9 @@ export type AgentRun = {
      * Optional agent capabilities disabled for this run slice.
      * `interactive-auth` blocks pausing to send an OAuth link; missing credentials
      * hard-fail instead. Default is enabled when omitted.
-     * TODO(#881, #883): child invocations currently disable interactive-auth, but
-     * may later need a path to force the auth flow when a delegated tool requires
-     * credentials the parent can already request.
+     * TODO(dcramer): Issues #881 and #883 track a path for child invocations to
+     * force interactive auth when a delegated tool requires credentials the
+     * parent can already request. Children currently disable it.
      */
     disabledFeatures?: readonly AgentFeature[];
     /** Absolute wall-clock deadline for this host request, in milliseconds. */
@@ -212,7 +211,7 @@ export type AgentRun = {
     state?: AgentRunState;
     /** Best-effort progress only. */
     onEvent?: (event: AgentEvent) => void | Promise<void>;
-    delivery?: AgentDelivery;
+    delivery?: Delivery;
     durability?: AgentDurability;
 };
 /** Return whether one optional agent capability is disabled for this run. */

package/dist/chat/agent-invocations/types.d.ts

@@ -107,6 +107,12 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -114,10 +120,22 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
@@ -232,6 +250,12 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -239,10 +263,22 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
@@ -355,6 +391,12 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -362,10 +404,22 @@ export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";
@@ -476,6 +530,12 @@ export declare const createAgentInvocationSchema: z.ZodObject<{
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         visibility: z.ZodEnum<{
             private: "private";
             public: "public";
@@ -483,10 +543,22 @@ export declare const createAgentInvocationSchema: z.ZodObject<{
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"local">;
         visibility: z.ZodLiteral<"private">;
         conversationId: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
+        location: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            tenantId: z.ZodOptional<z.ZodString>;
+            providerId: z.ZodString;
+        }, z.core.$strict>>;
         platform: z.ZodLiteral<"web">;
         visibility: z.ZodEnum<{
             private: "private";

package/dist/chat/api-turns/{accepted-reply.d.ts → assistant-message.d.ts}

@@ -1,11 +1,12 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ThreadConversationState } from "@/chat/state/conversation";
-/** Record a web-accepted assistant reply with agent history before the visible message. */
-export declare function commitWebAcceptedReply(args: {
+/** Store one assistant Message and its Agent history. */
+export declare function commitAssistantMessage(args: {
     agentMessage?: AssistantMessage;
     conversation: ThreadConversationState;
     conversationId: string;
     sessionId: string;
+    source?: "web";
     text: string;
     userMessageId: string;
 }): Promise<void>;

package/dist/chat/api-turns/cancellation.d.ts

@@ -12,7 +12,6 @@ export declare function createApiTurnCancellation(): ApiTurnCancellation;
 /** Close one cancelled Turn without a failure reply or retry. */
 export declare function completeCancelledApiTurn(args: {
     acknowledge(): Promise<void>;
-    actorId: string;
     cancellation?: ApiTurnCancellation;
     conversation: ThreadConversationState;
     conversationId: string;

package/dist/chat/api-turns/mailbox-input.d.ts

@@ -1,7 +1,4 @@
 /** Shared mailbox helpers for conversation-only turns. */
-import type { LocalActor } from "@/chat/actor";
 import type { InboundMessage } from "@/chat/task-execution/store";
 /** Join non-empty mailbox texts for one conversation-only turn. */
 export declare function joinMailboxText(messages: readonly InboundMessage[]): string;
-/** Local actor stamped on resource-event conversation-only turns. */
-export declare function localResourceEventActor(): LocalActor;

package/dist/chat/api-turns/routing.d.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
+import { type Source } from "@sentry/junior-plugin-api";
+import { type Actor } from "@/chat/actor";
+import type { ConversationPrivacy } from "@/chat/conversation-privacy";
+import type { ConversationAuthor, ConversationMessage } from "@/chat/state/conversation";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext } from "@/chat/task-execution/worker";
 declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
@@ -10,37 +14,34 @@ declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
     messageId: z.ZodString;
 }, z.core.$strict>;
 export type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
-/**
- * Local destination resource-event mailbox rows share the conversation-only runner.
- *
- * TODO(resource-events): Remove the dedicated `resource_event` work kind once
- * local/web destinations run plain mailbox system wakes the same way as any
- * other deferred conversation turn (no special batch/actor fork).
- */
-export type LocalResourceEventMailboxEntry = {
+export interface TurnInput {
+    actor: Actor;
+    author: ConversationAuthor;
     message: InboundMessage;
-    kind: "resource_event";
-};
+    source: "resource_event" | "web";
+}
+export type TurnIdentity = Pick<TurnInput, "actor" | "author" | "source">;
+/** Restore normalized Turn identity from one saved Message. */
+export declare function turnIdentityFromConversationMessage(message: ConversationMessage): TurnIdentity | undefined;
+/** Build the AgentRun Source for one Turn input. */
+export declare function sourceFromTurnInput(args: {
+    conversationId: string;
+    source: TurnInput["source"];
+    visibility?: ConversationPrivacy;
+}): Source;
 /** Return the active root API Turn for one Conversation, if it has one. */
 export declare function getActiveApiTurnId(conversationId: string): Promise<string | undefined>;
 /** Return the idle auth-paused root API Turn for one Conversation. */
 export declare function getAuthPausedApiTurnId(conversationId: string): Promise<string | undefined>;
 /**
- * Resolve conversation-only work from mailbox metadata or an active checkpoint.
+ * Resolve conversation-only work from new input or a saved Turn.
  *
- * Covers dashboard API turns and local destination resource-event wakes. Empty
- * resume wakes after yield carry no mailbox rows; durable active Turn state keeps
- * those wakes on this runner instead of falling through to Slack.
+ * User messages from the Conversation API run here. Resource events with a
+ * local Destination run here too. Saved state identifies a resumed Turn.
  */
 export declare function resolveApiTurnWork(context: ConversationWorkerContext): Promise<{
     kind: "mailbox";
-    batch: Array<{
-        message: InboundMessage;
-        metadata: ApiTurnMailboxMetadata;
-    }>;
-} | {
-    kind: "resource_event";
-    batch: LocalResourceEventMailboxEntry[];
+    batch: TurnInput[];
 } | {
     kind: "resume";
     turnId: string;

package/dist/chat/api-turns/work.d.ts

@@ -1,7 +1,7 @@
 import type { StateAdapter } from "chat";
 import { type Destination } from "@sentry/junior-plugin-api";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
-import type { WebActor } from "@/chat/actor";
+import { type WebActor } from "@/chat/actor";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { AgentRunner } from "@/chat/runtime/agent-runner";
 import { type InboundMessage } from "@/chat/task-execution/store";
@@ -90,7 +90,7 @@ export declare function appendAndEnqueueApiConversationMessage(input: AppendApiC
     exclusive: true;
 }): Promise<ApiConversationMessageAdmission>;
 export declare function appendAndEnqueueApiConversationMessage(input: AppendApiConversationMessageInput, options: EnqueueOptions): Promise<ApiConversationMessageAccepted>;
-/** Create the worker for messages from the Conversation API. */
+/** Create the worker for Turns that need no provider delivery. */
 export declare function createApiTurnWorker(agentRunner: AgentRunner, cancellation?: ApiTurnCancellation): (context: ConversationWorkerContext) => Promise<ConversationWorkerResult>;
 /** Route Conversation API work before other work. */
 export declare function routeApiTurnWork(options: {

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

@@ -1,10 +1,5 @@
-import { z } from "zod";
-/** Provider-neutral container associated with a conversation. */
-export declare const locationSchema: z.ZodObject<{
-    id: z.ZodString;
-    provider: z.ZodString;
-    tenantId: z.ZodOptional<z.ZodString>;
-    providerId: z.ZodString;
-}, z.core.$strict>;
-/** Validated provider location associated with a conversation. */
+import { locationSchema } from "@sentry/junior-plugin-api";
+import type { z } from "zod";
+export { locationSchema };
+/** Validated Location associated with a Conversation. */
 export type Location = z.output<typeof locationSchema>;

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

@@ -1,7 +1,7 @@
 import type { Destination, Source } from "@sentry/junior-plugin-api";
+import type { Location } from "@/chat/conversations/location";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { StoredSlackActor } from "@/chat/actor";
-import type { Location } from "@/chat/conversations/location";
 import type { SessionSource } from "@/chat/source";
 import type { AgentTurnUsage } from "@/chat/usage";
 export type ConversationSource = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack" | "web";
@@ -13,10 +13,18 @@ export interface ConversationExecution {
     status: ConversationStatus;
     updatedAtMs?: number;
 }
-/** Immutable parent correlation for a child conversation. */
-export interface ConversationLineage {
-    parentConversationId: string;
-}
+/**
+ * Durable Conversation owned by Junior.
+ *
+ * The final interface stores zero or one complete Location here. No Location
+ * means the Conversation stays in Junior's API and UI. A Location names the
+ * outside place where a provider can deliver the Conversation. Source may also
+ * contain this Location so the agent can use it. Delivery contains it when
+ * output may be sent there. Only Delivery allows output to be sent.
+ *
+ * `destination` and `sessionSource` temporarily duplicate parts of that model.
+ * Their field TODOs state when each legacy copy can be removed.
+ */
 export interface Conversation {
     channelName?: string;
     conversationId: string;
@@ -29,7 +37,9 @@ export interface Conversation {
         usage?: AgentTurnUsage;
     };
     lastActivityAtMs: number;
-    lineage?: ConversationLineage;
+    /** Immutable parent Conversation. */
+    parentConversationId?: string;
+    /** Optional provider coordinates associated with this Conversation. */
     location?: Location;
     actor?: StoredSlackActor;
     schemaVersion: 1;
@@ -53,7 +63,7 @@ export interface Conversation {
 }
 /** Persist and read durable conversation metadata for reporting surfaces. */
 export interface ConversationStore {
-    /** Create one destinationless child with immutable parent lineage. */
+    /** Create one Conversation with an immutable parent. */
     createChild(args: {
         childConversationId: string;
         parentConversationId: string;

package/dist/chat/event-tasks/tool-support.d.ts

@@ -97,6 +97,12 @@ export declare function requireEventTaskSlackContext(context: ToolRuntimeContext
         teamId: string;
         channelId: string;
         visibility: "private" | "public";
+        location?: {
+            id: string;
+            provider: string;
+            providerId: string;
+            tenantId?: string | undefined;
+        } | undefined;
         messageTs?: string | undefined;
         threadTs?: string | undefined;
     };

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

@@ -5,6 +5,13 @@
  * same system input for resource-event turns.
  */
 export declare const RESOURCE_EVENT_AUTHOR_ID = "UJRNEVENT";
+/** Synthetic Message author for resource-event input. */
+export declare const RESOURCE_EVENT_MESSAGE_AUTHOR: {
+    readonly fullName: "Junior event";
+    readonly isBot: true;
+    readonly userId: "UJRNEVENT";
+    readonly userName: "junior-event";
+};
 /** System execution actor for every resource-event turn. */
 export declare const RESOURCE_EVENT_SYSTEM_ACTOR: {
     readonly platform: "system";

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

@@ -1,32 +1,33 @@
 /**
- * Load destination and session source from the conversation record.
+ * Load Location, Destination, and session Source from the Conversation record.
  *
- * Destination is set once on the root conversation. Child conversations
- * inherit through parent lineage. Later turns and mailbox wakes use that
- * same destination so tools stay consistent for the whole conversation.
+ * Destination is set once on the root Conversation. A Conversation with a
+ * 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 { Location } from "@/chat/conversations/location";
 import type { ConversationStore } from "@/chat/conversations/store";
 export interface TurnSessionRouting {
     destination: Destination;
-    locationId?: string;
+    location?: Location;
     /** Present when the conversation already stores a session source. */
     source?: Source;
 }
-/** Full turn routing: destination plus a completed session source. */
+/** Conversation data with a required Destination and Source. */
 export type RequiredTurnSessionRouting = TurnSessionRouting & {
     source: Source;
 };
 /**
- * Resolve the conversation's destination and session source.
+ * Resolve the Conversation's Location, Destination, and session Source.
  *
- * Walks parent lineage when the conversation has no destination of its own.
+ * Reads parent Conversations when this Conversation has no Destination.
  */
 export declare function resolveConversationRouting(args: {
     conversationId: string;
     conversationStore?: ConversationStore;
 }): Promise<TurnSessionRouting | undefined>;
-/** Require conversation destination and session source from SQL. */
+/** Require the Conversation Destination and Source from SQL. */
 export declare function resolveTurnSessionRouting(args: {
     conversationId: string;
     conversationStore?: ConversationStore;

package/dist/chat/task-execution/slack-resource-event.d.ts

@@ -16,15 +16,23 @@ import type { SlackAdapter } from "@chat-adapter/slack";
 import type { Destination, SlackDestination } from "@sentry/junior-plugin-api";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { InboundMessage } from "@/chat/task-execution/store";
-/** Load Slack destination and threadTs for a resource-event wake. */
+/** Resolved Slack place for one plain resource-event wake, when a thread exists. */
+export type SlackResourceEventThread = {
+    destination: SlackDestination;
+    threadTs: string;
+};
+/**
+ * Load Slack destination and threadTs for a resource-event wake.
+ *
+ * Returns undefined when the Conversation has no Slack thread. The temporary
+ * synthetic Message/Thread bridge cannot invent one; the Slack worker must drop
+ * that wake instead of retrying.
+ */
 export declare function resolveSlackResourceEventThread(args: {
     conversationId: string;
     conversationStore?: ConversationStore;
     destination?: Destination;
-}): Promise<{
-    destination: SlackDestination;
-    threadTs: string;
-}>;
+}): Promise<SlackResourceEventThread | undefined>;
 /** Whether a mailbox row is a plain resource-event wake (no Slack envelope). */
 export declare function isPlainResourceEventRecord(record: InboundMessage): boolean;
 /**

package/dist/chat/task-input.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Render agent input for a task run.
+ *
+ * Section order and required prose live in `chat/README.md` under Task agent
+ * input. Empty optional fields are omitted.
+ */
+export declare function renderTaskInput(args: {
+    /** Stored task instruction, or subscription intent. */
+    instructions: string;
+    /** Human label for the matched resource, when present. */
+    about?: string;
+    /** Plugin guidance scoped under the instructions. */
+    guidance?: string;
+    /** Trusted one-line summary, when available. */
+    trustedSummary?: string;
+    /** Structured verified fields, when available. */
+    verifiedDetails?: Record<string, unknown>;
+    /** Untrusted provider text; never treated as instructions. */
+    externalText?: string;
+    externalTextMaxLength?: number;
+    trustedSummaryMaxLength?: number;
+}): string;

package/dist/{chunk-YXSBZRP7.js → chunk-32XSSFZV.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@sentry/junior",
-  version: "0.186.0",
+  version: "0.188.0",
   private: false,
   publishConfig: {
     access: "public"

package/dist/{chunk-HKFLRIBD.js → chunk-3HEZWDS5.js}

@@ -1,12 +1,12 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-NRMAOGRS.js";
+} from "./chunk-NZLZ4KYZ.js";
 import {
   skillRoots
 } from "./chunk-TXKUKMVO.js";
 import {
   logWarn
-} from "./chunk-3CVEE6LA.js";
+} from "./chunk-QIMN3FXL.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";

package/dist/{chunk-INQHUE72.js → chunk-6FGN7ZEG.js}

@@ -29,7 +29,9 @@ function assertRunConsistency(run) {
   switch (source.platform) {
     case "slack": {
       if (destination.platform !== "slack") {
-        throw new TypeError("Run source and destination platforms do not match");
+        throw new TypeError(
+          "Run source and destination platforms do not match"
+        );
       }
       if (source.teamId !== destination.teamId) {
         throw new TypeError("Slack source and destination teams do not match");
@@ -38,7 +40,9 @@ function assertRunConsistency(run) {
     }
     case "local": {
       if (destination.platform !== "local") {
-        throw new TypeError("Run source and destination platforms do not match");
+        throw new TypeError(
+          "Run source and destination platforms do not match"
+        );
       }
       if (source.conversationId !== destination.conversationId) {
         throw new TypeError(

package/dist/{chunk-TXLBLGNQ.js → chunk-6JZGXLL2.js}

@@ -7,23 +7,23 @@ import {
 import {
   formatProviderLabel,
   startOAuthFlow
-} from "./chunk-VQZYIVYN.js";
+} from "./chunk-UVUXFRYN.js";
 import {
   abandonReplacedPendingAuth,
   canReusePendingAuthLink
-} from "./chunk-VOGOTEW7.js";
+} from "./chunk-Z5SKZE5B.js";
 import {
   recordAuthorizationRequested
-} from "./chunk-H7X2G2KS.js";
+} from "./chunk-6YGFBU3A.js";
 import {
   AGENT_INVOCATION_MAILBOX_STATUSES
-} from "./chunk-VXL2LBPK.js";
+} from "./chunk-QVH6FW3T.js";
 import {
   TURN_REASONING_LEVELS
 } from "./chunk-D4YV5TDV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-NRMAOGRS.js";
+} from "./chunk-NZLZ4KYZ.js";
 import {
   credentialContextSchema
 } from "./chunk-CEMMLV5L.js";