@sentry/junior-plugin-api 0.74.1 → 0.75.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/index.ts
+// src/schemas.ts
 import { z } from "zod";
 var slackTeamIdSchema = z.string().regex(/^T[A-Z0-9]+$/);
 var slackConversationIdSchema = z.string().regex(/^(C|G|D)[A-Z0-9]+$/);
@@ -32,7 +32,7 @@ var sourceSchema = z.discriminatedUnion("platform", [
   slackSourceSchema,
   localSourceSchema
 ]);
-var agentPluginCredentialSubjectSchema = z.object({
+var pluginCredentialSubjectSchema = z.object({
   type: z.literal("user"),
   userId: exactActorUserIdSchema,
   allowedWhen: z.literal("private-direct-conversation")
@@ -81,6 +81,20 @@ var dispatchMetadataSchema = z.record(z.string(), z.string()).superRefine((metad
         path: [key]
       });
     }
+    if (/[\r\n]/.test(key)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Dispatch metadata keys must be single-line strings",
+        path: [key]
+      });
+    }
+    if (/[\r\n]/.test(value)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Dispatch metadata values must be single-line strings",
+        path: [key]
+      });
+    }
     if (value.length > 512) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
@@ -92,65 +106,73 @@ var dispatchMetadataSchema = z.record(z.string(), z.string()).superRefine((metad
 });
 var dispatchOptionsSchema = z.object({
   idempotencyKey: nonBlankStringSchema.pipe(z.string().max(512)),
-  credentialSubject: agentPluginCredentialSubjectSchema.optional(),
+  credentialSubject: pluginCredentialSubjectSchema.optional(),
   destination: slackDestinationSchema,
   input: nonBlankStringSchema.pipe(z.string().max(32e3)),
-  metadata: dispatchMetadataSchema.optional()
+  metadata: dispatchMetadataSchema.optional(),
+  source: sourceSchema
 }).strict();
-var AgentPluginToolInputError = class extends Error {
+
+// src/context.ts
+function isSlackDestination(destination) {
+  return destination?.platform === "slack";
+}
+
+// src/tools.ts
+var PluginToolInputError = class extends Error {
   constructor(message, options) {
     super(message, options);
-    this.name = "AgentPluginToolInputError";
+    this.name = "PluginToolInputError";
   }
 };
-function isSlackDestination(destination) {
-  return destination?.platform === "slack";
-}
-var agentPluginProviderNameSchema = z.string().regex(/^[a-z][a-z0-9-]*$/);
-var agentPluginGrantNameSchema = z.string().regex(/^[a-z][a-z0-9.-]*$/);
-var agentPluginGrantAccessSchema = z.union([
-  z.literal("read"),
-  z.literal("write")
+
+// src/credentials.ts
+import { z as z2 } from "zod";
+var pluginProviderNameSchema = z2.string().regex(/^[a-z][a-z0-9-]*$/);
+var pluginGrantNameSchema = z2.string().regex(/^[a-z][a-z0-9.-]*$/);
+var pluginGrantAccessSchema = z2.union([
+  z2.literal("read"),
+  z2.literal("write")
 ]);
-var agentPluginAuthorizationSchema = z.object({
-  provider: agentPluginProviderNameSchema,
+var pluginAuthorizationSchema = z2.object({
+  provider: pluginProviderNameSchema,
   scope: nonBlankStringSchema.optional(),
-  type: z.literal("oauth")
+  type: z2.literal("oauth")
 }).strict();
-var agentPluginProviderAccountSchema = z.object({
+var pluginProviderAccountSchema = z2.object({
   id: nonBlankStringSchema,
   label: nonBlankStringSchema.optional(),
   url: nonBlankStringSchema.optional()
 }).strict();
-var agentPluginGrantSchema = z.object({
-  access: agentPluginGrantAccessSchema,
-  name: agentPluginGrantNameSchema,
+var pluginGrantSchema = z2.object({
+  access: pluginGrantAccessSchema,
+  name: pluginGrantNameSchema,
   reason: nonBlankStringSchema.optional(),
-  requirements: z.array(nonBlankStringSchema).min(1).optional()
+  requirements: z2.array(nonBlankStringSchema).min(1).optional()
 }).strict();
-var agentPluginCredentialHeaderTransformSchema = z.object({
-  domain: z.string().min(1),
-  headers: z.record(z.string(), z.string()).refine((headers) => Object.keys(headers).length > 0)
+var pluginCredentialHeaderTransformSchema = z2.object({
+  domain: z2.string().min(1),
+  headers: z2.record(z2.string(), z2.string()).refine((headers) => Object.keys(headers).length > 0)
 }).strict();
-var agentPluginCredentialLeaseSchema = z.object({
-  account: agentPluginProviderAccountSchema.optional(),
-  authorization: agentPluginAuthorizationSchema.optional(),
-  expiresAt: z.string().refine((value) => Number.isFinite(Date.parse(value))),
-  headerTransforms: z.array(agentPluginCredentialHeaderTransformSchema).min(1)
+var pluginCredentialLeaseSchema = z2.object({
+  account: pluginProviderAccountSchema.optional(),
+  authorization: pluginAuthorizationSchema.optional(),
+  expiresAt: z2.string().refine((value) => Number.isFinite(Date.parse(value))),
+  headerTransforms: z2.array(pluginCredentialHeaderTransformSchema).min(1)
 }).strict();
-var agentPluginCredentialResultSchema = z.discriminatedUnion("type", [
-  z.object({
-    lease: agentPluginCredentialLeaseSchema,
-    type: z.literal("lease")
+var pluginCredentialResultSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    lease: pluginCredentialLeaseSchema,
+    type: z2.literal("lease")
   }).strict(),
-  z.object({
-    authorization: agentPluginAuthorizationSchema.optional(),
+  z2.object({
+    authorization: pluginAuthorizationSchema.optional(),
     message: nonBlankStringSchema,
-    type: z.literal("needed")
+    type: z2.literal("needed")
   }).strict(),
-  z.object({
+  z2.object({
     message: nonBlankStringSchema,
-    type: z.literal("unavailable")
+    type: z2.literal("unavailable")
   }).strict()
 ]);
 var EgressAuthRequired = class extends Error {
@@ -161,24 +183,27 @@ var EgressAuthRequired = class extends Error {
     this.authorization = options?.authorization;
   }
 };
+
+// src/registration.ts
 var PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
 function defineJuniorPlugin(plugin) {
   if ("pluginConfig" in plugin) {
     throw new Error(
-      "pluginConfig is no longer supported. Put runtime metadata in manifest and state prefixes on the plugin registration."
+      "pluginConfig is no longer supported. Put runtime metadata in manifest or plugin registration fields."
     );
   }
+  if ("name" in plugin) {
+    throw new Error("defineJuniorPlugin() uses manifest.name for identity.");
+  }
   const manifest = plugin.manifest;
   if (!manifest) {
     throw new Error(
       "defineJuniorPlugin() requires a manifest. Use a package name string in defineJuniorPlugins([...]) for plugin.yaml packages."
     );
   }
-  const name = plugin.name ?? manifest.name;
+  const name = manifest.name;
   if (!name) {
-    throw new Error(
-      "Junior plugin registrations must include name or manifest.name."
-    );
+    throw new Error("Junior plugin manifest.name is required.");
   }
   if (!PLUGIN_NAME_RE.test(name)) {
     throw new Error(
@@ -195,26 +220,13 @@ function defineJuniorPlugin(plugin) {
       `Junior plugin "${name}" manifest.description is required.`
     );
   }
-  if (plugin.name && manifest.name && plugin.name !== manifest.name) {
-    throw new Error(
-      `Junior plugin registration name "${plugin.name}" must match manifest.name "${manifest.name}".`
-    );
-  }
   return {
-    ...plugin,
-    name
+    ...plugin
   };
 }
 export {
-  AgentPluginToolInputError,
   EgressAuthRequired,
-  agentPluginAuthorizationSchema,
-  agentPluginCredentialHeaderTransformSchema,
-  agentPluginCredentialLeaseSchema,
-  agentPluginCredentialResultSchema,
-  agentPluginCredentialSubjectSchema,
-  agentPluginGrantSchema,
-  agentPluginProviderAccountSchema,
+  PluginToolInputError,
   defineJuniorPlugin,
   destinationSchema,
   dispatchOptionsSchema,
@@ -222,6 +234,14 @@ export {
   localDestinationSchema,
   localRequesterSchema,
   localSourceSchema,
+  nonBlankStringSchema,
+  pluginAuthorizationSchema,
+  pluginCredentialHeaderTransformSchema,
+  pluginCredentialLeaseSchema,
+  pluginCredentialResultSchema,
+  pluginCredentialSubjectSchema,
+  pluginGrantSchema,
+  pluginProviderAccountSchema,
   requesterSchema,
   slackDestinationSchema,
   slackRequesterSchema,

package/dist/manifest.d.ts

@@ -0,0 +1,74 @@
+export interface PluginOAuthConfig {
+    authorizeEndpoint: string;
+    authorizeParams?: Record<string, string>;
+    clientIdEnv: string;
+    clientSecretEnv: string;
+    scope?: string;
+    /**
+     * Treat a provider token response with `scope: ""` like an omitted scope and
+     * fall back to the requested scope string when storing the token.
+     */
+    treatEmptyScopeAsUnreported?: boolean;
+    tokenAuthMethod?: "body" | "basic";
+    tokenEndpoint: string;
+    tokenExtraHeaders?: Record<string, string>;
+}
+export interface PluginOAuthBearerCredentials {
+    apiHeaders?: Record<string, string>;
+    authTokenEnv: string;
+    authTokenPlaceholder?: string;
+    domains: string[];
+    type: "oauth-bearer";
+}
+export type PluginCredentials = PluginOAuthBearerCredentials;
+export interface PluginNpmRuntimeDependency {
+    package: string;
+    type: "npm";
+    version: string;
+}
+export interface PluginSystemRuntimeDependency {
+    package: string;
+    type: "system";
+}
+export interface PluginSystemRuntimeDependencyFromUrl {
+    sha256: string;
+    type: "system";
+    url: string;
+}
+export type PluginRuntimeDependency = PluginNpmRuntimeDependency | PluginSystemRuntimeDependency | PluginSystemRuntimeDependencyFromUrl;
+export interface PluginRuntimePostinstallCommand {
+    args?: string[];
+    cmd: string;
+    sudo?: boolean;
+}
+export interface PluginMcpConfig {
+    allowedTools?: string[];
+    headers?: Record<string, string>;
+    transport: "http";
+    url: string;
+}
+export interface PluginEnvVarDeclaration {
+    default?: string;
+    exposeToCommandEnv?: boolean;
+}
+export interface PluginManifest {
+    apiHeaders?: Record<string, string>;
+    capabilities?: string[];
+    commandEnv?: Record<string, string>;
+    configKeys?: string[];
+    credentials?: PluginCredentials;
+    description: string;
+    displayName: string;
+    domains?: string[];
+    envVars?: Record<string, PluginEnvVarDeclaration>;
+    mcp?: PluginMcpConfig;
+    name: string;
+    oauth?: PluginOAuthConfig;
+    runtimeDependencies?: PluginRuntimeDependency[];
+    runtimePostinstall?: PluginRuntimePostinstallCommand[];
+    target?: {
+        commandFlags?: string[];
+        configKey: string;
+        type: string;
+    };
+}

package/dist/operations.d.ts

@@ -0,0 +1,93 @@
+import type { PluginContext } from "./context";
+import type { PluginDb } from "./database";
+import type { Dispatch, DispatchOptions, DispatchResult } from "./dispatch";
+import type { PluginReadState, PluginState } from "./state";
+export type PluginConversationStatus = "active" | "completed" | "failed" | "hung" | "superseded";
+export interface PluginConversationSummary {
+    channelName?: string;
+    conversationId: string;
+    displayTitle: string;
+    lastActivityAt: string;
+    lastUpdatedAt: string;
+    source?: "api" | "internal" | "local" | "plugin" | "scheduler" | "slack";
+    status: PluginConversationStatus;
+}
+export interface PluginConversations {
+    listRecent(options?: {
+        limit?: number;
+    }): Promise<PluginConversationSummary[]>;
+}
+export interface HeartbeatHookContext extends PluginContext {
+    agent: {
+        dispatch(options: DispatchOptions): Promise<DispatchResult>;
+        get(id: string): Promise<Dispatch | undefined>;
+    };
+    nowMs: number;
+    state: PluginState;
+}
+export interface HeartbeatResult {
+    dispatchCount?: number;
+}
+export interface StorageMigrationResult {
+    existing: number;
+    migrated: number;
+    missing: number;
+    scanned: number;
+    skipped?: number;
+}
+export interface StorageMigrationContext extends PluginContext {
+    db: PluginDb;
+    state: PluginState;
+}
+export type PluginOperationalTone = "danger" | "good" | "neutral" | "warning";
+export interface PluginOperationalMetric {
+    label: string;
+    tone?: PluginOperationalTone;
+    value: string;
+}
+export interface PluginOperationalField {
+    key: string;
+    label: string;
+}
+export interface PluginOperationalRecord {
+    id: string;
+    tone?: PluginOperationalTone;
+    values: Record<string, string>;
+}
+export interface PluginOperationalRecordSet {
+    fields?: PluginOperationalField[];
+    emptyText?: string;
+    records?: PluginOperationalRecord[];
+    title: string;
+}
+export interface PluginOperationalReportContent {
+    generatedAt?: string;
+    metrics?: PluginOperationalMetric[];
+    recordSets?: PluginOperationalRecordSet[];
+    title?: string;
+}
+export interface PluginOperationalReport extends PluginOperationalReportContent {
+    pluginName: string;
+}
+export interface OperationalReportHookContext extends PluginContext {
+    conversations: PluginConversations;
+    nowMs: number;
+    state: PluginReadState;
+}
+export type PluginRouteMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "ALL";
+export type PluginRouteHandler = {
+    bivarianceHack(request: Request): Promise<Response> | Response;
+}["bivarianceHack"];
+export interface PluginRoute {
+    handler: PluginRouteHandler;
+    method?: PluginRouteMethod | PluginRouteMethod[];
+    path: string;
+}
+export interface RouteRegistrationHookContext extends PluginContext {
+}
+export interface SlackConversationLink {
+    url: string;
+}
+export interface SlackConversationLinkHookContext extends PluginContext {
+    conversationId: string;
+}

package/dist/prompt.d.ts

@@ -0,0 +1,42 @@
+import type { InvocationContext, PluginContext } from "./context";
+import type { PluginSessionState, PluginSessionStateAppend, PluginState } from "./state";
+export interface UserPromptContribution {
+    id: string;
+    text: string;
+}
+export interface UserPromptContributionResult {
+    contributions?: UserPromptContribution[];
+    sessionState?: PluginSessionStateAppend[];
+}
+export type UserPromptHookContext = PluginContext & InvocationContext & {
+    isFirstPrompt: boolean;
+    session: PluginSessionState;
+    state: PluginState;
+    userText: string;
+};
+export interface PluginTaskEnqueueOptions {
+    idempotencyKey: string;
+    name: string;
+    payload?: unknown;
+}
+export interface PluginTaskEnqueueResult {
+    id: string;
+    status: "created" | "already_exists";
+}
+export interface PluginTaskQueue {
+    enqueue(options: PluginTaskEnqueueOptions): Promise<PluginTaskEnqueueResult>;
+}
+export type TurnObservationHookContext = PluginContext & InvocationContext & {
+    observationId: string;
+    tasks: PluginTaskQueue;
+};
+export interface PluginTaskContext extends PluginContext {
+    id: string;
+    name: string;
+    observation?: {
+        load(): Promise<unknown | undefined>;
+    };
+    payload?: unknown;
+    state: PluginState;
+}
+export type PluginTaskHandler = (ctx: PluginTaskContext) => Promise<void> | void;

package/dist/registration.d.ts

@@ -0,0 +1,13 @@
+import type { PluginDatabaseConfig } from "./database";
+import type { PluginHooks } from "./hooks";
+import type { PluginManifest } from "./manifest";
+export type PluginRegistrationInput = {
+    database?: PluginDatabaseConfig;
+    hooks?: PluginHooks;
+    manifest: PluginManifest;
+    packageName?: string;
+};
+export interface PluginRegistration extends PluginRegistrationInput {
+}
+/** Define one Junior plugin registration for app and build-time wiring. */
+export declare function defineJuniorPlugin(plugin: PluginRegistrationInput): PluginRegistration;

package/dist/schemas.d.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+export declare const nonBlankStringSchema: z.ZodString;
+/** Runtime-owned Slack address for routing future work or side effects. */
+export declare const slackDestinationSchema: z.ZodObject<{
+    platform: z.ZodLiteral<"slack">;
+    teamId: z.ZodString;
+    channelId: z.ZodString;
+}, z.core.$strict>;
+/** Runtime-owned local CLI conversation address. */
+export declare const localDestinationSchema: z.ZodObject<{
+    platform: z.ZodLiteral<"local">;
+    conversationId: z.ZodString;
+}, z.core.$strict>;
+/** Runtime-owned provider-neutral address for routing future work or side effects. */
+export declare const destinationSchema: 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">;
+/** Runtime-owned Slack coordinates for the inbound invocation. */
+export declare const slackSourceSchema: z.ZodObject<{
+    platform: z.ZodLiteral<"slack">;
+    teamId: z.ZodString;
+    channelId: z.ZodString;
+    messageTs: z.ZodOptional<z.ZodString>;
+    threadTs: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Runtime-owned local CLI coordinates for the inbound invocation. */
+export declare const localSourceSchema: z.ZodObject<{
+    platform: z.ZodLiteral<"local">;
+    conversationId: z.ZodString;
+}, z.core.$strict>;
+/** Runtime-owned provider-neutral coordinates for the inbound invocation. */
+export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    platform: z.ZodLiteral<"slack">;
+    teamId: z.ZodString;
+    channelId: z.ZodString;
+    messageTs: z.ZodOptional<z.ZodString>;
+    threadTs: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    platform: z.ZodLiteral<"local">;
+    conversationId: z.ZodString;
+}, z.core.$strict>], "platform">;
+/** Stable user credential subject shape accepted from plugins. */
+export declare const pluginCredentialSubjectSchema: z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    userId: z.ZodString;
+    allowedWhen: z.ZodLiteral<"private-direct-conversation">;
+}, z.core.$strict>;
+export declare const slackRequesterSchema: 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>;
+export declare const localRequesterSchema: 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>;
+/** Runtime-provided requester identity visible to plugin hooks. */
+export declare const requesterSchema: 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>], "platform">;
+/** Plugin dispatch request accepted by Junior core. */
+export declare const dispatchOptionsSchema: z.ZodObject<{
+    idempotencyKey: z.ZodPipe<z.ZodString, z.ZodString>;
+    credentialSubject: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"user">;
+        userId: z.ZodString;
+        allowedWhen: z.ZodLiteral<"private-direct-conversation">;
+    }, z.core.$strict>>;
+    destination: z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>;
+    input: z.ZodPipe<z.ZodString, z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+        messageTs: z.ZodOptional<z.ZodString>;
+        threadTs: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        conversationId: z.ZodString;
+    }, z.core.$strict>], "platform">;
+}, z.core.$strict>;

package/dist/state.d.ts

@@ -0,0 +1,20 @@
+export interface PluginState {
+    delete(key: string): Promise<void>;
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set(key: string, value: unknown, ttlMs?: number): Promise<void>;
+    setIfNotExists(key: string, value: unknown, ttlMs?: number): Promise<boolean>;
+    withLock<T>(key: string, ttlMs: number, callback: () => Promise<T>): Promise<T>;
+}
+export interface PluginReadState {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+}
+export interface PluginSessionStateAppend {
+    key: string;
+    value: unknown;
+}
+export interface PluginSessionState {
+    list<T = unknown>(key: string): Promise<Array<{
+        createdAtMs: number;
+        value: T;
+    }>>;
+}

package/dist/tools.d.ts

@@ -0,0 +1,107 @@
+import type { PluginContext, LocalInvocationContext, Requester, SlackInvocationContext } from "./context";
+import type { PluginCredentialSubject } from "./credentials";
+import type { PluginState } from "./state";
+export interface PluginEnv {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+}
+export interface PluginDecision {
+    deny(message: string): void;
+    replaceInput(input: Record<string, unknown>): void;
+}
+/** Thrown when a plugin tool rejects invalid model or user input. */
+export declare class PluginToolInputError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface PluginSandbox {
+    juniorRoot: string;
+    root: string;
+    readFile(path: string): Promise<Uint8Array | null>;
+    run(input: {
+        args?: string[];
+        cmd: string;
+        cwd?: string;
+        env?: Record<string, string>;
+        sudo?: boolean;
+    }): Promise<{
+        exitCode: number;
+        stderr: string;
+        stdout: string;
+    }>;
+    writeFile(input: {
+        content: string | Uint8Array;
+        mode?: number;
+        path: string;
+    }): Promise<void>;
+}
+export interface SandboxPrepareHookContext extends PluginContext {
+    requester?: Requester;
+    sandbox: PluginSandbox;
+}
+export interface BeforeToolExecuteHookContext extends PluginContext {
+    decision: PluginDecision;
+    env: PluginEnv;
+    requester?: Requester;
+    tool: {
+        input: Record<string, unknown>;
+        name: string;
+    };
+}
+export type PluginToolExecute<TInput = unknown> = {
+    bivarianceHack(input: TInput, options: {
+        experimental_context?: unknown;
+    }): Promise<unknown> | unknown;
+}["bivarianceHack"];
+export interface PluginToolDefinition<TInput = unknown> {
+    annotations?: unknown;
+    description: string;
+    executionMode?: unknown;
+    inputSchema: unknown;
+    prepareArguments?: (args: unknown) => unknown;
+    /**
+     * @deprecated Put tool-selection and usage guidance directly in `description`
+     * and parameter descriptions. Retained for compatibility; may be removed in a
+     * future major version.
+     */
+    promptGuidelines?: string[];
+    /**
+     * @deprecated Put tool-selection and usage guidance directly in `description`
+     * and parameter descriptions. Retained for compatibility; may be removed in a
+     * future major version.
+     */
+    promptSnippet?: string;
+    execute?: PluginToolExecute<TInput>;
+}
+export interface SlackToolRegistrationHookContext {
+    /**
+     * Capabilities of the source Slack conversation exposed to this plugin.
+     * Recomputed from `source.channelId`, not from `destination`.
+     */
+    channelCapabilities: {
+        canAddReactions: boolean;
+        canCreateCanvas: boolean;
+        canPostToChannel: boolean;
+    };
+    credentialSubject?: PluginCredentialSubject;
+}
+interface BaseToolRegistrationHookContext extends PluginContext {
+    /**
+     * Opaque Junior conversation/session identity for this turn.
+     * Interactive Slack turns use `slack:{channelId}:{threadTs}`.
+     * Scheduled/API turns use an internal id such as `agent-dispatch:{id}`.
+     * Do not parse as Slack unless the value starts with `slack:`.
+     */
+    conversationId?: string;
+    state: PluginState;
+    userText?: string;
+}
+interface SlackToolRegistrationContext extends BaseToolRegistrationHookContext, SlackInvocationContext {
+    slack: SlackToolRegistrationHookContext;
+}
+interface LocalToolRegistrationContext extends BaseToolRegistrationHookContext, LocalInvocationContext {
+    slack?: never;
+}
+export type ToolRegistrationHookContext = LocalToolRegistrationContext | SlackToolRegistrationContext;
+export {};