@sentry/junior 0.137.0 → 0.139.0

package/dist/{catalog-runtime-MD66YLFV.js → catalog-runtime-GCCFYPIK.js}

@@ -1,16 +1,16 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-36EG34YI.js";
-import "./chunk-BZAMASJP.js";
-import "./chunk-77VDLF3Z.js";
+} from "./chunk-6OHTDR4F.js";
+import "./chunk-CXH25EL4.js";
+import "./chunk-RUIXF3YQ.js";
 import "./chunk-HZF5P5UN.js";
 import "./chunk-F3B2YJ76.js";
-import "./chunk-T6Z5S6PQ.js";
+import "./chunk-2ECYPYKP.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-5PNJMOY5.js";
-import "./chunk-XZ7NPXAB.js";
+import "./chunk-C2N6MNO4.js";
+import "./chunk-U7CMWQ7Z.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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

@@ -16,7 +16,6 @@ import type { Actor } from "@/chat/actor";
 import type { SandboxRef } from "@/chat/sandbox/ref";
 import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
 import type { SandboxEgressSignalTransport } from "@/chat/sandbox/egress/signals";
-import type { AuthorizationFlowMode } from "@/chat/services/auth-pause";
 import type { OAuthAuthorization } from "@/chat/oauth-authorization";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
 import type { SlackConversationContext } from "@/chat/slack/conversation-context";
@@ -49,6 +48,21 @@ export interface AgentRunSteeringMessage {
     timestampMs?: number;
     userAttachments?: AgentRunAttachment[];
 }
+/** Model-safe input for one asynchronously delegated child-agent task. */
+export type SpawnAgentInput = {
+    name?: string;
+    reasoningLevel?: TurnReasoningLevel;
+    task: string;
+};
+/** Handle returned after a child-agent task is durably scheduled. */
+export type SpawnAgentResult = {
+    invocationId: string;
+};
+/** Runtime-bound child-agent capability exposed to model-facing tool wiring. */
+export type SpawnAgent = (input: SpawnAgentInput, options: {
+    signal?: AbortSignal;
+    toolCallId: string;
+}) => Promise<SpawnAgentResult>;
 /** Carries the user-visible content and prior transcript for one agent-run slice. */
 export interface AgentRunInput {
     actor?: AgentRunInstructionActor;
@@ -61,10 +75,20 @@ export interface AgentRunInput {
     piMessages?: PiMessage[];
     conversationContext?: string;
 }
-/** Carries identity and addressing needed to route tools, auth, and delivery. */
+/**
+ * Identity and addressing for one run.
+ *
+ * Set `actor` first (who runs). Derive `credentialContext` with
+ * `credentialContextForActor(actor, subject?)` unless a caller already bound
+ * credentials (dispatch with delegated subject). They name the same principal
+ * except when a system actor carries `credentialContext.subject` for delegated
+ * user tokens.
+ */
 export interface AgentRunRouting {
-    credentialContext?: CredentialContext;
+    /** Who this run executes as. Prefer always setting this. */
     actor?: Actor;
+    /** Credential authority projected from actor (plus optional subject). */
+    credentialContext?: CredentialContext;
     source: Source;
     slackConversation?: SlackConversationContext;
     /**
@@ -85,13 +109,27 @@ export interface AgentRunRouting {
     };
     toolChannelId?: string;
 }
+/** Optional agent capabilities that a run slice can turn off. */
+export declare const AGENT_RUN_FEATURES: readonly ["handoff", "interactive-auth", "subagents"];
+/** One optional agent capability controlled by run policy. */
+export type AgentRunFeature = (typeof AGENT_RUN_FEATURES)[number];
+/** Return whether one optional agent capability is disabled for this run. */
+export declare function isAgentRunFeatureDisabled(policy: Pick<AgentRunPolicy, "disabledFeatures"> | undefined, feature: AgentRunFeature): boolean;
 /** Carries execution limits and dependency overrides for one run slice. */
 export interface AgentRunPolicy {
+    /**
+     * 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.
+     */
+    disabledFeatures?: readonly AgentRunFeature[];
     /** Absolute wall-clock deadline for this host request, in milliseconds. */
     turnDeadlineAtMs?: number;
     /** Cancels provider work when the owning host request is abandoned. */
     signal?: AbortSignal;
-    authorizationFlowMode?: AuthorizationFlowMode;
     /** Explicit per-agent reasoning level. When set, adaptive routing is disabled. */
     reasoningLevel?: TurnReasoningLevel;
     configuration?: Record<string, unknown>;
@@ -141,6 +179,8 @@ export declare class RetryableDeliveryError extends Error {
 }
 /** Carries durable-worker ports that commit or update resumable run state. */
 export interface AgentRunDurability {
+    /** Schedule delegated work with authority bound by the active parent run. */
+    spawnAgent?: SpawnAgent;
     onInputCommitted?: () => void | Promise<void>;
     /** Return true when the durable worker should pause at the next Pi boundary. */
     shouldYield?: () => boolean;

package/dist/chat/agent-dispatch/heartbeat.d.ts

@@ -15,6 +15,11 @@ export declare function recoverPendingDispatchMailboxAppends(args: {
     conversationWorkQueue: ConversationWorkQueue;
     nowMs: number;
 }): Promise<void>;
+/** Repair invocation creation that stopped before its idempotent mailbox append. */
+export declare function recoverPendingAgentInvocationMailboxAppends(args: {
+    conversationWorkQueue: ConversationWorkQueue;
+    nowMs: number;
+}): Promise<void>;
 /** Run the core heartbeat phases. */
 export declare function runHeartbeat(args: {
     conversationWorkQueue?: ConversationWorkQueue;

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

@@ -47,7 +47,7 @@ export interface DispatchTurnResult {
 }
 /** Dispatch-owned authority supplied to the shared turn runtime. */
 export interface DispatchTurnContext {
-    authorizationFlowMode: "disabled";
+    disabledFeatures: readonly ["interactive-auth"];
     channelConfiguration: ChannelConfigurationService;
     credentialContext: CredentialContext;
     destinationVisibility: DestinationVisibility;

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

@@ -0,0 +1,8 @@
+/** Named child cannot accept another invocation until its active work ends. */
+export declare class AgentInvocationBusyError extends Error {
+    constructor(name: string);
+}
+/** Parent already has the maximum number of non-terminal child invocations. */
+export declare class AgentInvocationLimitError extends Error {
+    constructor(limit: number);
+}

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

@@ -0,0 +1,12 @@
+import type { StateAdapter } from "chat";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { AgentRunRequest, SpawnAgent } from "@/chat/agent/request";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+type SpawnOptions = {
+    conversationStore?: ConversationStore;
+    queue: ConversationWorkQueue | (() => ConversationWorkQueue);
+    state?: StateAdapter;
+};
+/** Bind one run's runtime-owned authority to the model-safe spawn capability. */
+export declare function bindSpawnAgent(request: AgentRunRequest, options: SpawnOptions): SpawnAgent | undefined;
+export {};

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

@@ -0,0 +1,44 @@
+import { type AgentInvocation, type CreateAgentInvocationInput } from "./types";
+/** Cap concurrent non-terminal children one parent can keep in flight. */
+export declare const MAX_ACTIVE_AGENT_INVOCATIONS_PER_PARENT = 8;
+/** Return the stable identity for one retry-safe delegated task. */
+export declare function getAgentInvocationId(parentConversationId: string, idempotencyKey: string): string;
+/** Return the stable child identity for one invocation without a named binding. */
+export declare function getUnnamedAgentConversationId(invocationId: string): string;
+/** Return the stable child identity for one named binding. */
+export declare function getNamedAgentConversationId(parentConversationId: string, name: string): string;
+/** Return the stable turn identity advanced by one agent invocation. */
+export declare function getAgentInvocationTurnId(invocationId: string): string;
+/** Return the stable mailbox identity for one agent invocation. */
+export declare function getAgentInvocationMessageId(invocationId: string): string;
+/** Read one durable agent invocation. */
+export declare function getAgentInvocation(invocationId: string): Promise<AgentInvocation | undefined>;
+/** Resolve the single invocation that may resume for one child conversation. */
+export declare function getActiveAgentInvocationForConversation(childConversationId: string): Promise<AgentInvocation | undefined>;
+/**
+ * Create or replay one invocation, reusing named child conversations and
+ * keeping unnamed child identities scoped to the invocation.
+ */
+export declare function createAgentInvocation(rawInput: CreateAgentInvocationInput, nowMs?: number): Promise<AgentInvocation>;
+/** List bounded invocation records whose mailbox append still needs repair. */
+export declare function listPendingAgentInvocationMailboxAppends(limit?: number): Promise<AgentInvocation[]>;
+/** Record that the invocation's idempotent mailbox append completed. */
+export declare function markAgentInvocationMailboxAppended(invocationId: string, nowMs?: number): Promise<void>;
+/** Mark one non-terminal invocation as actively executing. */
+export declare function markAgentInvocationRunning(invocationId: string, nowMs?: number): Promise<AgentInvocation | undefined>;
+/** Mark one invocation as waiting for another shared execution slice. */
+export declare function markAgentInvocationAwaitingResume(invocationId: string, nowMs?: number): Promise<void>;
+/** Persist one terminal invocation result without overwriting an earlier result. */
+export declare function completeAgentInvocation(args: {
+    invocationId: string;
+    result: string;
+    status: "completed";
+    nowMs?: number;
+} | {
+    errorMessage: string;
+    invocationId: string;
+    status: "blocked" | "failed";
+    nowMs?: number;
+}): Promise<AgentInvocation | undefined>;
+/** Return whether an invocation already owns its immutable terminal result. */
+export declare function isTerminalAgentInvocation(invocation: AgentInvocation): boolean;

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

@@ -0,0 +1,449 @@
+import { z } from "zod";
+import { AGENT_INVOCATION_STATUSES } from "@/db/schema/agent-invocations";
+export declare const agentNameSchema: z.ZodString;
+export declare const agentBindingSchema: z.ZodObject<{
+    childConversationId: z.ZodString;
+    name: z.ZodString;
+    parentConversationId: z.ZodString;
+}, z.core.$strict>;
+export declare const agentInvocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    actor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    agentName: z.ZodOptional<z.ZodString>;
+    childConversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    credentialContext: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        actor: z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        actor: z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"private-direct-conversation">;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"slack-direct-conversation">;
+                teamId: z.ZodString;
+                channelId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"scheduled-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"scheduled-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"event-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"event-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "allowedWhen">>;
+    }, z.core.$strict>]>>;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    destinationVisibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    input: z.ZodString;
+    invocationId: z.ZodString;
+    mailboxStatus: z.ZodEnum<{
+        pending: "pending";
+        appended: "appended";
+    }>;
+    parentConversationId: z.ZodString;
+    reasoningLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+        messageTs: z.ZodOptional<z.ZodString>;
+        threadTs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        visibility: z.ZodLiteral<"private">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    updatedAtMs: z.ZodNumber;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        awaiting_resume: "awaiting_resume";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    actor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    agentName: z.ZodOptional<z.ZodString>;
+    childConversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    credentialContext: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        actor: z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        actor: z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"private-direct-conversation">;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"slack-direct-conversation">;
+                teamId: z.ZodString;
+                channelId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"scheduled-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"scheduled-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"event-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"event-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "allowedWhen">>;
+    }, z.core.$strict>]>>;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    destinationVisibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    input: z.ZodString;
+    invocationId: z.ZodString;
+    mailboxStatus: z.ZodEnum<{
+        pending: "pending";
+        appended: "appended";
+    }>;
+    parentConversationId: z.ZodString;
+    reasoningLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+        messageTs: z.ZodOptional<z.ZodString>;
+        threadTs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        visibility: z.ZodLiteral<"private">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    updatedAtMs: z.ZodNumber;
+    result: z.ZodString;
+    status: z.ZodLiteral<"completed">;
+    terminalAtMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    actor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    agentName: z.ZodOptional<z.ZodString>;
+    childConversationId: z.ZodString;
+    createdAtMs: z.ZodNumber;
+    credentialContext: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        actor: z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        actor: z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"private-direct-conversation">;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"slack-direct-conversation">;
+                teamId: z.ZodString;
+                channelId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"scheduled-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"scheduled-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"event-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"event-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "allowedWhen">>;
+    }, z.core.$strict>]>>;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    destinationVisibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    input: z.ZodString;
+    invocationId: z.ZodString;
+    mailboxStatus: z.ZodEnum<{
+        pending: "pending";
+        appended: "appended";
+    }>;
+    parentConversationId: z.ZodString;
+    reasoningLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+        messageTs: z.ZodOptional<z.ZodString>;
+        threadTs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        visibility: z.ZodLiteral<"private">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    updatedAtMs: z.ZodNumber;
+    errorMessage: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        blocked: "blocked";
+    }>;
+    terminalAtMs: z.ZodNumber;
+}, z.core.$strict>], "status">;
+export declare const createAgentInvocationSchema: z.ZodObject<{
+    actor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    agentName: z.ZodOptional<z.ZodString>;
+    credentialContext: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        actor: z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        actor: z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"private-direct-conversation">;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"slack-direct-conversation">;
+                teamId: z.ZodString;
+                channelId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"scheduled-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"scheduled-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            userId: z.ZodString;
+            allowedWhen: z.ZodLiteral<"event-task">;
+            taskId: z.ZodString;
+            binding: z.ZodObject<{
+                type: z.ZodLiteral<"event-task">;
+                plugin: z.ZodString;
+                taskId: z.ZodString;
+                signature: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "allowedWhen">>;
+    }, z.core.$strict>]>>;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+    destinationVisibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+    idempotencyKey: z.ZodString;
+    input: z.ZodString;
+    parentConversationId: z.ZodString;
+    reasoningLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        none: "none";
+    }>>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+        messageTs: z.ZodOptional<z.ZodString>;
+        threadTs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        visibility: z.ZodLiteral<"private">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+}, z.core.$strict>;
+export type AgentBinding = z.output<typeof agentBindingSchema>;
+export type AgentInvocation = z.output<typeof agentInvocationSchema>;
+export type AgentInvocationStatus = (typeof AGENT_INVOCATION_STATUSES)[number];
+export type CreateAgentInvocationInput = z.input<typeof createAgentInvocationSchema>;