@sentry/junior 0.107.1 → 0.109.0

package/dist/{catalog-runtime-FOFNPR3P.js → catalog-runtime-DMGJSLV2.js}

@@ -1,13 +1,15 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-YIPD3L6L.js";
-import "./chunk-VIXFG2VC.js";
-import "./chunk-O24R4DCK.js";
+} from "./chunk-3SXUV423.js";
+import "./chunk-TT6GMXNA.js";
+import "./chunk-PLB7MRCQ.js";
+import "./chunk-ISMWX44P.js";
 import "./chunk-OB42YVAE.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";
-import "./chunk-7FBGKXPE.js";
 import "./chunk-3V7OFJZC.js";
+import "./chunk-IVVGFRQQ.js";
+import "./chunk-OCD3OZRK.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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

@@ -596,6 +596,20 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strict>]>;
 /** One versioned event read from the durable conversation log. */
 export type ConversationEvent = z.output<typeof conversationEventSchema>;
+/** A decoded message-summary event and its readable history boundary. */
+export type MessagesSummarizedEvent = Omit<Extract<ConversationEvent, {
+    schemaVersion: 1;
+}>, "data"> & {
+    data: Extract<ConversationEventData, {
+        type: "messages_summarized";
+    }>;
+};
+/** Projection-ready message events paired with their authoritative boundary. */
+export interface MessageHistory {
+    events: ConversationEvent[];
+    compaction: MessagesSummarizedEvent | undefined;
+    historyFromSeq: number;
+}
 declare const storedConversationEventSchema: z.ZodObject<{
     schemaVersion: z.ZodNumber;
     seq: z.ZodNumber;
@@ -746,11 +760,8 @@ export interface ConversationEventStore {
     loadCurrentHistory(conversationId: string): Promise<ConversationEvent[]>;
     /** Events in the history version containing `seq`, when it exists. */
     loadHistoryContaining(conversationId: string, seq: number, throughSeq?: number): Promise<ConversationEvent[] | undefined>;
-    /** Current source/destination messages and their latest summary snapshot. */
-    loadMessageHistory(conversationId: string): Promise<{
-        events: ConversationEvent[];
-        compaction: ConversationEvent | undefined;
-    }>;
+    /** Projection-ready message suffix, summary snapshot, and readable boundary. */
+    loadMessageHistory(conversationId: string): Promise<MessageHistory>;
     /** All events across every history version in `seq` order. */
     loadHistory(conversationId: string): Promise<ConversationEvent[]>;
 }

package/dist/chat/conversations/message-projection.d.ts

@@ -1,6 +1,4 @@
-import type { ConversationEvent } from "./history";
+import type { MessageHistory } from "./history";
 import type { ConversationMessage } from "@/chat/state/conversation";
-/** Reduce canonical message facts into destination-facing history. */
-export declare function projectConversationMessages(events: ConversationEvent[], options?: {
-    historyFromSeq?: number;
-}): ConversationMessage[];
+/** Reduce a boundary-bearing message-history suffix into destination history. */
+export declare function projectConversationMessages(history: Pick<MessageHistory, "events" | "historyFromSeq">): ConversationMessage[];

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

@@ -38,13 +38,6 @@ export declare class SqlStore implements ConversationStore {
         updatedAtMs: number;
         visibility?: ConversationPrivacy;
     }): Promise<void>;
-    /** Copy one conversation record and retained metrics into SQL during backfill. */
-    backfillConversation(sourceConversation: Conversation, metrics?: {
-        durationMs: number;
-        executionDurationMs: number;
-        executionUsage?: AgentTurnUsage;
-        usage?: AgentTurnUsage;
-    }): Promise<void>;
     listByActivity(args?: {
         limit?: number;
         offset?: number;

package/dist/chat/log-context.d.ts

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export type LogAttributeValue = string | number | boolean | string[];
+export type LogAttributes = Record<string, LogAttributeValue>;
+/** Provider-neutral correlation data inherited by logs and spans in an operation. */
+export interface LogContext {
+    conversationId?: string;
+    platform?: string;
+    requestId?: string;
+    messageConversationId?: string;
+    destinationName?: string;
+    userId?: string;
+    userName?: string;
+    userEmail?: string;
+    runId?: string;
+    actorType?: string;
+    actorId?: string;
+    assistantUserName?: string;
+    modelId?: string;
+    skillName?: string;
+    httpMethod?: string;
+    httpPath?: string;
+    urlFull?: string;
+    userAgent?: string;
+}
+/** Async attribute domain consumed directly by LogTape. */
+export declare const logContextStorage: AsyncLocalStorage<LogAttributes>;
+/** Convert provider-neutral domain context to stable telemetry attributes. */
+export declare function logContextToAttributes(context: LogContext): LogAttributes;
+/** Run an operation with merged context, restoring its parent on completion. */
+export declare function runWithLogContext<T>(context: LogContext, attributes: LogAttributes, callback: () => T): T;
+/** Run an operation with raw attributes, restoring its parent on completion. */
+export declare function runWithLogAttributes<T>(attributes: LogAttributes, callback: () => T): T;
+/** Merge raw attributes into the current scoped operation. */
+export declare function updateLogAttributes(attributes: LogAttributes): void;
+/** Merge context and attributes into the current scoped operation. */
+export declare function updateLogContext(context: LogContext, attributes: LogAttributes): void;
+/** Read the typed context bound to the current operation. */
+export declare function getBoundLogContext(): LogContext;
+/** Read the attributes bound to the current operation. */
+export declare function getBoundLogAttributes(): LogAttributes;

package/dist/chat/logging.d.ts

@@ -1,9 +1,8 @@
 import type { Logger as ChatSdkLogger } from "chat";
+import { type LogAttributes, type LogContext } from "@/chat/log-context";
 import * as Sentry from "@/chat/sentry";
 import type { AgentTurnUsage } from "@/chat/usage";
-type Primitive = string | number | boolean;
-type AttributeValue = Primitive | string[];
-export type LogAttributes = Record<string, AttributeValue>;
+export type { LogAttributes, LogContext } from "@/chat/log-context";
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export interface EmittedLogRecord {
     attributes: LogAttributes;
@@ -11,26 +10,6 @@ export interface EmittedLogRecord {
     eventName: string;
     level: LogLevel;
 }
-export interface LogContext {
-    conversationId?: string;
-    platform?: string;
-    requestId?: string;
-    slackThreadId?: string;
-    slackUserId?: string;
-    slackUserName?: string;
-    slackUserEmail?: string;
-    slackChannelId?: string;
-    runId?: string;
-    actorType?: string;
-    actorId?: string;
-    assistantUserName?: string;
-    modelId?: string;
-    skillName?: string;
-    httpMethod?: string;
-    httpPath?: string;
-    urlFull?: string;
-    userAgent?: string;
-}
 export type TracePropagationHeaders = Partial<Record<"baggage" | "sentry-trace" | "traceparent", string>>;
 interface SentryUserIdentity {
     id: string | number;
@@ -51,7 +30,6 @@ export declare const log: {
 /** Create a Chat SDK logger that routes records through Junior's logging backend. */
 export declare function createChatSdkLogger(): ChatSdkLogger;
 export declare function withLogContext<T>(context: LogContext, callback: () => Promise<T>): Promise<T>;
-export declare function setLogContext(context: LogContext): void;
 export declare function getLogContextAttributes(): LogAttributes;
 /** Return inherited log context filtered to attributes valid for the span operation. */
 export declare function getLogContextAttributesForSpan(op: string): LogAttributes;
@@ -75,7 +53,7 @@ export declare function logWarn(eventName: string, context?: LogContext, attribu
 export declare function logError(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
 /** Log an error with exception capture; returns the Sentry event ID if available. */
 export declare function logException(error: unknown, eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): string | undefined;
-/** Set log context and Sentry scope metadata for the current request. */
+/** Add context to the current operation and Sentry scope. */
 export declare function setTags(context?: LogContext): void;
 /** Create a LogContext from an incoming HTTP request. */
 export declare function createRequestContext(request: Request, context?: Partial<LogContext>): LogContext;
@@ -107,4 +85,3 @@ export declare function serializeGenAiAttribute(value: unknown, maxChars?: numbe
 export declare function extractGenAiUsageSummary(...sources: unknown[]): AgentTurnUsage;
 /** Extract GenAI token and estimated USD cost attributes for tracing. */
 export declare function extractGenAiUsageAttributes(...sources: unknown[]): Partial<Record<"gen_ai.usage.input_tokens" | "gen_ai.usage.output_tokens" | "gen_ai.usage.cache_read.input_tokens" | "gen_ai.usage.cache_creation.input_tokens" | "gen_ai.usage.reasoning.output_tokens", number> & Partial<Record<"app.cost.input_usd" | "app.cost.output_usd" | "app.cost.cache_read_usd" | "app.cost.cache_write_usd" | "app.cost.total_usd", number>>>;
-export {};

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

@@ -57,6 +57,12 @@ export declare function cancelResourceEventSubscription(input: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<ResourceEventSubscription | undefined>;
+/** Cancel every active resource event subscription bound to one conversation. */
+export declare function cancelSubscriptions(input: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<void>;
 /** Find active subscriptions interested in a normalized provider event. */
 export declare function findMatchingResourceEventSubscriptions(input: {
     eventType: string;

package/dist/chat/runtime/slack-resume.d.ts

@@ -26,7 +26,7 @@ interface ResumeSlackTurnArgs {
         conversationId: string;
         sessionId: string;
     }) => Promise<void>;
-    onSuccess?: (reply: AgentRunResult) => Promise<void>;
+    commitResult?: (result: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
     onAuthPause?: (pause: {
         providerDisplayName: string;
@@ -45,7 +45,7 @@ interface ResumePreparedTurn {
     inputMessageIds?: string[];
     initialStatus?: AssistantStatusSpec;
     replyContext: ResumeReplyContext;
-    onSuccess?: (reply: AgentRunResult) => Promise<void>;
+    commitResult?: (result: AgentRunResult) => Promise<void>;
     onFailure?: (error: unknown) => Promise<void>;
     onAuthPause?: (pause: {
         providerDisplayName: string;

package/dist/chat/runtime/slack-runtime.d.ts

@@ -43,6 +43,9 @@ export interface SlackTurnOptions extends ReplyHooks {
 }
 export interface SlackTurnRuntimeDependencies<TPreparedState> {
     assistantUserName: string;
+    cancelEventSubscriptions: (input: {
+        conversationId: string;
+    }) => Promise<void>;
     getChannelId: (thread: Thread, message: Message) => string | undefined;
     getPreparedConversationContext: (preparedState: TPreparedState) => string | undefined;
     getThreadId: (thread: Thread, message: Message) => string | undefined;

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

@@ -64,7 +64,6 @@ export declare function persistCompletedSessionRecord(args: {
     sliceId?: number;
     allMessages: PiMessage[];
     loadedSkillNames?: string[];
-    logContext: SessionRecordLogContext;
     modelId: string;
     actor?: Actor;
     reasoningLevel?: string;
@@ -79,7 +78,6 @@ export declare function completeDeliveredTurn(args: {
     destinationVisibility?: ConversationPrivacy;
     durationMs?: number;
     loadedSkillNames?: string[];
-    logContext: SessionRecordLogContext;
     messages: PiMessage[];
     modelId: string;
     actor?: Actor;

package/dist/chat/slack/reply.d.ts

@@ -1,24 +1,12 @@
-import { type SlackReplyFooter } from "@/chat/slack/footer";
-export type PlannedSlackReplyStage = "thread_reply" | "thread_reply_continuation";
-export interface PlannedSlackReplyPost {
-    stage: PlannedSlackReplyStage;
-    text: string;
-}
-/** Plan the Slack posts for one completed assistant message. */
-export declare function planSlackAssistantMessagePosts(text: string): PlannedSlackReplyPost[];
 /**
- * Deliver planned Slack reply posts over raw Slack Web API calls for resume and
- * callback handlers that do not have a Chat SDK thread object.
+ * Send one destination-visible Slack reply.
+ *
+ * Chunks oversized text, builds the conversation footer from
+ * `conversationId`, and posts through the shared Slack outbound boundary.
  */
-export declare function postSlackApiReplyPosts(args: {
-    beforePost?: () => Promise<void>;
-    footer?: SlackReplyFooter;
+export declare function sendSlackReply(args: {
     channelId: string;
-    onPostError?: (context: {
-        error: unknown;
-        messageTs?: string;
-        stage: PlannedSlackReplyStage;
-    }) => Promise<void> | void;
+    conversationId: string;
+    text: string;
     threadTs?: string;
-    posts: PlannedSlackReplyPost[];
 }): Promise<string | undefined>;

package/dist/chat/state/conversation.d.ts

@@ -7,6 +7,7 @@ export interface ConversationAuthor {
 }
 export interface ConversationMessageMeta {
     attachmentCount?: number;
+    eventType?: string;
     explicitMention?: boolean;
     imageAttachmentCount?: number;
     imageFileIds?: string[];

package/dist/chat/task-execution/slack-work.d.ts

@@ -1,20 +1,247 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
-import { Message, ThreadImpl, type SerializedMessage, type SerializedThread, type StateAdapter } from "chat";
+import { Message, ThreadImpl, type StateAdapter } from "chat";
+import { z } from "zod";
 import type { SlackTurnOptions } from "@/chat/runtime/slack-runtime";
 import type { ConversationStore } from "@/chat/conversations/store";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
 import { type SlackActorProfile } from "@/chat/actor";
-export type SlackConversationRoute = "mention" | "subscribed";
-export interface SlackConversationMessageMetadata {
-    [key: string]: unknown;
-    installation?: SlackInstallationContext;
-    message: SerializedMessage;
-    platform: "slack";
-    route: SlackConversationRoute;
-    thread: SerializedThread;
-}
+declare const slackConversationRouteSchema: z.ZodEnum<{
+    mention: "mention";
+    subscribed: "subscribed";
+}>;
+export type SlackConversationRoute = z.output<typeof slackConversationRouteSchema>;
+declare const slackConversationMessageMetadataSchema: z.ZodUnion<readonly [z.ZodObject<{
+    installation: z.ZodOptional<z.ZodObject<{
+        enterpriseId: z.ZodOptional<z.ZodString>;
+        isEnterpriseInstall: z.ZodOptional<z.ZodBoolean>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    message: z.ZodObject<{
+        _type: z.ZodLiteral<"chat:Message">;
+        attachments: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                file: "file";
+                audio: "audio";
+                video: "video";
+            }>;
+            url: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+        author: z.ZodObject<{
+            userId: z.ZodString;
+            userName: z.ZodString;
+            fullName: z.ZodString;
+            isBot: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"unknown">]>;
+            isMe: z.ZodBoolean;
+        }, z.core.$strict>;
+        formatted: z.ZodCustom<import("chat").Root, import("chat").Root>;
+        id: z.ZodString;
+        isMention: z.ZodOptional<z.ZodBoolean>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            siteName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        metadata: z.ZodObject<{
+            dateSent: z.ZodISODateTime;
+            edited: z.ZodBoolean;
+            editedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        raw: z.ZodUnknown;
+        text: z.ZodString;
+        threadId: z.ZodString;
+    }, z.core.$strict>;
+    platform: z.ZodLiteral<"slack">;
+    route: z.ZodEnum<{
+        mention: "mention";
+        subscribed: "subscribed";
+    }>;
+    thread: z.ZodObject<{
+        _type: z.ZodLiteral<"chat:Thread">;
+        adapterName: z.ZodLiteral<"slack">;
+        channelId: z.ZodString;
+        channelVisibility: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            private: "private";
+            external: "external";
+            workspace: "workspace";
+        }>>;
+        currentMessage: z.ZodOptional<z.ZodObject<{
+            _type: z.ZodLiteral<"chat:Message">;
+            attachments: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    image: "image";
+                    file: "file";
+                    audio: "audio";
+                    video: "video";
+                }>;
+                url: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                size: z.ZodOptional<z.ZodNumber>;
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>;
+            author: z.ZodObject<{
+                userId: z.ZodString;
+                userName: z.ZodString;
+                fullName: z.ZodString;
+                isBot: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"unknown">]>;
+                isMe: z.ZodBoolean;
+            }, z.core.$strict>;
+            formatted: z.ZodCustom<import("chat").Root, import("chat").Root>;
+            id: z.ZodString;
+            isMention: z.ZodOptional<z.ZodBoolean>;
+            links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                url: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                imageUrl: z.ZodOptional<z.ZodString>;
+                siteName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            metadata: z.ZodObject<{
+                dateSent: z.ZodISODateTime;
+                edited: z.ZodBoolean;
+                editedAt: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            raw: z.ZodUnknown;
+            text: z.ZodString;
+            threadId: z.ZodString;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        isDM: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    installation: z.ZodOptional<z.ZodObject<{
+        enterpriseId: z.ZodOptional<z.ZodString>;
+        isEnterpriseInstall: z.ZodOptional<z.ZodBoolean>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    message: z.ZodObject<{
+        _type: z.ZodLiteral<"chat:Message">;
+        attachments: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                file: "file";
+                audio: "audio";
+                video: "video";
+            }>;
+            url: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            mimeType: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+        author: z.ZodObject<{
+            userId: z.ZodString;
+            userName: z.ZodString;
+            fullName: z.ZodString;
+            isBot: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"unknown">]>;
+            isMe: z.ZodBoolean;
+        }, z.core.$strict>;
+        formatted: z.ZodCustom<import("chat").Root, import("chat").Root>;
+        id: z.ZodString;
+        isMention: z.ZodOptional<z.ZodBoolean>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            imageUrl: z.ZodOptional<z.ZodString>;
+            siteName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        metadata: z.ZodObject<{
+            dateSent: z.ZodISODateTime;
+            edited: z.ZodBoolean;
+            editedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        raw: z.ZodUnknown;
+        text: z.ZodString;
+        threadId: z.ZodString;
+    }, z.core.$strict>;
+    platform: z.ZodLiteral<"slack">;
+    route: z.ZodEnum<{
+        mention: "mention";
+        subscribed: "subscribed";
+    }>;
+    thread: z.ZodObject<{
+        _type: z.ZodLiteral<"chat:Thread">;
+        adapterName: z.ZodLiteral<"slack">;
+        channelId: z.ZodString;
+        channelVisibility: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            private: "private";
+            external: "external";
+            workspace: "workspace";
+        }>>;
+        currentMessage: z.ZodOptional<z.ZodObject<{
+            _type: z.ZodLiteral<"chat:Message">;
+            attachments: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    image: "image";
+                    file: "file";
+                    audio: "audio";
+                    video: "video";
+                }>;
+                url: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                mimeType: z.ZodOptional<z.ZodString>;
+                size: z.ZodOptional<z.ZodNumber>;
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>>;
+            author: z.ZodObject<{
+                userId: z.ZodString;
+                userName: z.ZodString;
+                fullName: z.ZodString;
+                isBot: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"unknown">]>;
+                isMe: z.ZodBoolean;
+            }, z.core.$strict>;
+            formatted: z.ZodCustom<import("chat").Root, import("chat").Root>;
+            id: z.ZodString;
+            isMention: z.ZodOptional<z.ZodBoolean>;
+            links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                url: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                imageUrl: z.ZodOptional<z.ZodString>;
+                siteName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            metadata: z.ZodObject<{
+                dateSent: z.ZodISODateTime;
+                edited: z.ZodBoolean;
+                editedAt: z.ZodOptional<z.ZodISODateTime>;
+            }, z.core.$strict>;
+            raw: z.ZodUnknown;
+            text: z.ZodString;
+            threadId: z.ZodString;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        isDM: z.ZodBoolean;
+    }, z.core.$strict>;
+    kind: z.ZodLiteral<"resource_event">;
+    resourceEvent: z.ZodObject<{
+        eventKey: z.ZodString;
+        eventType: z.ZodString;
+        provider: z.ZodString;
+        resourceRef: z.ZodString;
+        subscriptionId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type SlackConversationMessageMetadata = z.output<typeof slackConversationMessageMetadataSchema>;
 type SlackInboxTurnOptions = SlackTurnOptions & {
     ack: () => Promise<void>;
     isFinalAttempt: boolean;

package/dist/chat/tool-support/turn-deadline-result.d.ts

@@ -0,0 +1,3 @@
+import type { AfterToolCallResult, AgentToolResult } from "@earendil-works/pi-agent-core";
+/** Mark an unknown tool outcome as caused by an internal execution-slice deadline. */
+export declare function annotateTurnDeadlineToolResult(result: AgentToolResult<unknown>): AfterToolCallResult | undefined;

package/dist/chunk-3SXUV423.js

@@ -0,0 +1,10 @@
+import {
+  createPluginCatalogRuntime
+} from "./chunk-TT6GMXNA.js";
+
+// src/chat/plugins/catalog-runtime.ts
+var pluginCatalogRuntime = createPluginCatalogRuntime();
+
+export {
+  pluginCatalogRuntime
+};