@sentry/junior-plugin-api 0.75.0 → 0.76.0

package/dist/cli.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Public Commander-based CLI contract for plugin-owned admin commands.
+ * Junior owns the root command, plugin namespaces, context injection, and exit
+ * normalization; plugins only configure subcommands under their namespace.
+ */
+import type { Command } from "commander";
+import type { PluginContext } from "./context";
+export interface PluginCliIo {
+    writeError(text: string): Promise<void> | void;
+    writeOutput(text: string): Promise<void> | void;
+}
+export interface PluginCliActionCommand {
+    name: string;
+    summary: string;
+}
+/** Host/admin context exposed to plugin-owned CLI command actions. */
+export interface PluginCliActionContext extends Pick<PluginContext, "db" | "log" | "plugin"> {
+    command: PluginCliActionCommand;
+    io: PluginCliIo;
+}
+/** Plugin action callback wrapped by the Junior host for context and exit codes. */
+export type PluginCliActionHandler<Args extends unknown[] = unknown[]> = (ctx: PluginCliActionContext, ...args: Args) => Promise<number | void> | number | void;
+export interface PluginCliHost {
+    /** Wrap a Commander action so Junior can inject context and normalize exits. */
+    action<Args extends unknown[]>(handler: PluginCliActionHandler<Args>): (...args: Args) => Promise<void>;
+}
+/** Plugin-owned top-level CLI command registration. */
+export interface PluginCliCommandDefinition {
+    /** Configure subcommands under the host-created top-level namespace. */
+    configure(command: Command, junior: PluginCliHost): void;
+    /** Unique host-level command namespace owned by this plugin. */
+    name: string;
+    /** One-line summary used in generated command help. */
+    summary: string;
+}
+/** Plugin-owned CLI command catalog. */
+export interface PluginCliDefinition {
+    commands: PluginCliCommandDefinition[];
+}

package/dist/context.d.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
-import { destinationSchema, localRequesterSchema, requesterSchema, slackRequesterSchema, sourceSchema } from "./schemas";
-import type { PluginDb } from "./database";
+import type { ZodTypeAny } from "zod";
+import { destinationSchema, localRequesterSchema, platformSchema, requesterSchema, slackRequesterSchema, sourceSchema } from "./schemas";
+/** Runtime platform name without source or destination coordinates. */
+export type Platform = z.output<typeof platformSchema>;
 export type Requester = z.output<typeof requesterSchema>;
 export type SlackRequester = z.output<typeof slackRequesterSchema>;
 export type LocalRequester = z.output<typeof localRequesterSchema>;
@@ -11,6 +13,7 @@ export type SlackSource = Extract<Source, {
 export type LocalSource = Extract<Source, {
     platform: "local";
 }>;
+export type SourceType = Source["type"];
 export type Destination = z.output<typeof destinationSchema>;
 export type SlackDestination = Extract<Destination, {
     platform: "slack";
@@ -26,9 +29,31 @@ export interface PluginLogger {
     info(message: string, metadata?: Record<string, unknown>): void;
     warn(message: string, metadata?: Record<string, unknown>): void;
 }
+export interface PluginModel {
+    /** Run a host-owned structured model call without exposing provider credentials. */
+    completeObject<TSchema extends ZodTypeAny>(input: {
+        maxTokens?: number;
+        prompt: string;
+        schema: TSchema;
+        system?: string;
+    }): Promise<{
+        object: z.infer<TSchema>;
+    }>;
+}
+export interface PluginEmbedder {
+    /** Embed plugin-owned text for derived retrieval without exposing provider credentials. */
+    embedTexts(input: {
+        texts: string[];
+    }): Promise<{
+        dimensions: number;
+        model: string;
+        provider: string;
+        vectors: number[][];
+    }>;
+}
 export interface PluginContext {
-    /** Shared database connection for plugins that declare database access. */
-    db?: PluginDb;
+    /** Shared Drizzle database connection for plugin runtime code. */
+    db: unknown;
     log: PluginLogger;
     plugin: PluginMetadata;
 }
@@ -40,20 +65,33 @@ interface BaseInvocationContext {
     conversationId?: string;
 }
 export interface SlackInvocationContext extends BaseInvocationContext {
-    /** Runtime-owned default outbound destination for this invocation, if any. */
-    destination?: SlackDestination;
+    /** Runtime-owned default outbound destination for this invocation. */
+    destination: SlackDestination;
     requester?: SlackRequester;
     /** Runtime-owned source where the invocation came from. */
     source: SlackSource;
 }
 export interface LocalInvocationContext extends BaseInvocationContext {
-    /** Runtime-owned default outbound destination for this invocation, if any. */
-    destination?: LocalDestination;
+    /** Runtime-owned default outbound destination for this invocation. */
+    destination: LocalDestination;
     requester?: LocalRequester;
     /** Runtime-owned source where the invocation came from. */
     source: LocalSource;
 }
 export type InvocationContext = LocalInvocationContext | SlackInvocationContext;
+/** Build a normalized Slack source from runtime-owned Slack coordinates. */
+export declare function createSlackSource(input: {
+    channelId: string;
+    messageTs?: string;
+    teamId: string;
+    threadTs?: string;
+}): SlackSource;
+/** Build a normalized local source from a local conversation id. */
+export declare function createLocalSource(conversationId: string): LocalSource;
+/** Return whether a source is private to a person or restricted group. */
+export declare function isPrivateSource(source: Source): boolean;
+/** Return the stable source identity used for idempotency and attribution. */
+export declare function getSourceKey(source: Source): string | undefined;
 /** Narrow a runtime destination to the Slack-specific address shape. */
 export declare function isSlackDestination(destination: Destination | undefined): destination is SlackDestination;
 export {};

package/dist/credentials.d.ts

@@ -14,6 +14,19 @@ export declare const pluginProviderAccountSchema: z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+/** Runtime schema for OAuth tokens stored by the host for plugin credentials. */
+export declare const pluginStoredTokensSchema: z.ZodObject<{
+    account: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    accessToken: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    refreshToken: z.ZodString;
+    refreshTokenExpiresAt: z.ZodOptional<z.ZodNumber>;
+    scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 /** Runtime schema for a plugin-defined outbound credential grant. */
 export declare const pluginGrantSchema: z.ZodObject<{
     access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
@@ -130,16 +143,12 @@ export interface PluginResolvedCredentialUser {
     type: "user";
     userId: string;
 }
-export interface PluginStoredTokens {
-    account?: PluginProviderAccount;
-    accessToken: string;
-    expiresAt?: number;
-    refreshToken: string;
-    scope?: string;
-}
+export type PluginStoredTokens = z.output<typeof pluginStoredTokensSchema>;
 export interface PluginUserTokenSlot {
     get(): Promise<PluginStoredTokens | undefined>;
     set(tokens: PluginStoredTokens): Promise<void>;
+    /** Run token refresh work after the host has serialized this user/provider slot, or throw after a bounded wait. */
+    withRefresh<T>(callback: () => Promise<T>): Promise<T>;
     userId: string;
 }
 export interface PluginTokenStore {

package/dist/hooks.d.ts

@@ -1,7 +1,10 @@
 import type { EgressHookContext, EgressResponseHookContext, IssueCredentialHookContext, PluginCredentialResult, PluginGrant, PluginProviderAccount, ResolveOAuthAccountHookContext } from "./credentials";
 import type { HeartbeatHookContext, HeartbeatResult, OperationalReportHookContext, PluginOperationalReportContent, PluginRoute, RouteRegistrationHookContext, SlackConversationLink, SlackConversationLinkHookContext, StorageMigrationContext, StorageMigrationResult } from "./operations";
 import type { BeforeToolExecuteHookContext, PluginToolDefinition, SandboxPrepareHookContext, ToolRegistrationHookContext } from "./tools";
+import type { PromptMessage, SystemPromptContext, UserPromptContext } from "./prompt";
 export interface PluginHooks {
+    systemPrompt?(ctx: SystemPromptContext): Promise<PromptMessage[]> | PromptMessage[];
+    userPrompt?(ctx: UserPromptContext): Promise<PromptMessage[] | undefined> | PromptMessage[] | undefined;
     beforeToolExecute?(ctx: BeforeToolExecuteHookContext): Promise<void> | void;
     grantForEgress?(ctx: EgressHookContext): Promise<PluginGrant | undefined> | PluginGrant | undefined;
     heartbeat?(ctx: HeartbeatHookContext): Promise<HeartbeatResult | void> | HeartbeatResult | void;

package/dist/index.d.ts

@@ -1,11 +1,13 @@
 export * from "./schemas";
 export * from "./context";
 export * from "./state";
+export { promptMessageSchema, type PromptMessage, type SystemPromptContext, type UserPromptContext, } from "./prompt";
 export * from "./dispatch";
-export * from "./database";
+export * from "./tasks";
 export * from "./tools";
 export * from "./operations";
 export * from "./credentials";
 export * from "./hooks";
+export * from "./cli";
 export * from "./manifest";
 export * from "./registration";

package/dist/index.js

@@ -7,11 +7,14 @@ var exactActorUserIdSchema = z.string().min(1).refine(
   (value) => value === value.trim() && value.toLowerCase() !== "unknown"
 );
 var nonBlankStringSchema = z.string().refine((value) => value.trim().length > 0);
-var slackDestinationSchema = z.object({
+var platformSchema = z.enum(["slack", "local"]);
+var sourceTypeSchema = z.enum(["pub", "priv"]);
+var slackAddressSchema = z.object({
   platform: z.literal("slack"),
   teamId: slackTeamIdSchema,
   channelId: slackConversationIdSchema
 }).strict();
+var slackDestinationSchema = slackAddressSchema;
 var localDestinationSchema = z.object({
   platform: z.literal("local"),
   conversationId: localConversationIdSchema
@@ -20,14 +23,16 @@ var destinationSchema = z.discriminatedUnion("platform", [
   slackDestinationSchema,
   localDestinationSchema
 ]);
-var slackSourceSchema = z.object({
-  platform: z.literal("slack"),
-  teamId: slackTeamIdSchema,
-  channelId: slackConversationIdSchema,
+var slackSourceSchema = slackAddressSchema.extend({
+  type: sourceTypeSchema,
   messageTs: nonBlankStringSchema.optional(),
   threadTs: nonBlankStringSchema.optional()
 }).strict();
-var localSourceSchema = localDestinationSchema;
+var localSourceSchema = z.object({
+  platform: z.literal("local"),
+  type: z.literal("priv"),
+  conversationId: localConversationIdSchema
+}).strict();
 var sourceSchema = z.discriminatedUnion("platform", [
   slackSourceSchema,
   localSourceSchema
@@ -114,10 +119,76 @@ var dispatchOptionsSchema = z.object({
 }).strict();
 
 // src/context.ts
+function createSlackSource(input) {
+  return {
+    platform: "slack",
+    type: slackSourceType(input.channelId),
+    teamId: input.teamId,
+    channelId: input.channelId,
+    ...input.messageTs ? { messageTs: input.messageTs } : {},
+    ...input.threadTs ? { threadTs: input.threadTs } : {}
+  };
+}
+function slackSourceType(channelId) {
+  if (channelId.startsWith("C")) return "pub";
+  if (channelId.startsWith("D") || channelId.startsWith("G")) return "priv";
+  throw new Error(`Unsupported Slack channel ID prefix: ${channelId}`);
+}
+function createLocalSource(conversationId) {
+  return {
+    platform: "local",
+    type: "priv",
+    conversationId
+  };
+}
+function isPrivateSource(source) {
+  return source.type === "priv";
+}
+function getSourceKey(source) {
+  if (source.platform === "local") {
+    return source.conversationId;
+  }
+  const messageKey = source.threadTs ?? source.messageTs;
+  if (!messageKey) {
+    return void 0;
+  }
+  return `slack:${source.teamId}:${source.channelId}:${messageKey}`;
+}
 function isSlackDestination(destination) {
   return destination?.platform === "slack";
 }
 
+// src/prompt.ts
+import { z as z2 } from "zod";
+var promptMessageSchema = z2.object({
+  text: z2.string().trim().min(1).max(8e3)
+}).strict();
+
+// src/tasks.ts
+import { z as z3 } from "zod";
+var pluginRunTranscriptEntrySchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("message"),
+    role: z3.enum(["user", "assistant"]),
+    text: z3.string().min(1)
+  }).strict(),
+  z3.object({
+    type: z3.literal("toolResult"),
+    toolName: z3.string().min(1),
+    isError: z3.boolean(),
+    text: z3.string().min(1).optional()
+  }).strict()
+]);
+var pluginRunContextSchema = z3.object({
+  completedAtMs: z3.number().finite(),
+  conversationId: z3.string().min(1),
+  destination: destinationSchema,
+  requester: requesterSchema.optional(),
+  runId: z3.string().min(1),
+  source: sourceSchema,
+  transcript: z3.array(pluginRunTranscriptEntrySchema)
+}).strict();
+
 // src/tools.ts
 var PluginToolInputError = class extends Error {
   constructor(message, options) {
@@ -127,52 +198,60 @@ var PluginToolInputError = class extends Error {
 };
 
 // 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")
+import { z as z4 } from "zod";
+var pluginProviderNameSchema = z4.string().regex(/^[a-z][a-z0-9-]*$/);
+var pluginGrantNameSchema = z4.string().regex(/^[a-z][a-z0-9.-]*$/);
+var pluginGrantAccessSchema = z4.union([
+  z4.literal("read"),
+  z4.literal("write")
 ]);
-var pluginAuthorizationSchema = z2.object({
+var pluginAuthorizationSchema = z4.object({
   provider: pluginProviderNameSchema,
   scope: nonBlankStringSchema.optional(),
-  type: z2.literal("oauth")
+  type: z4.literal("oauth")
 }).strict();
-var pluginProviderAccountSchema = z2.object({
+var pluginProviderAccountSchema = z4.object({
   id: nonBlankStringSchema,
   label: nonBlankStringSchema.optional(),
   url: nonBlankStringSchema.optional()
 }).strict();
-var pluginGrantSchema = z2.object({
+var pluginStoredTokensSchema = z4.object({
+  account: pluginProviderAccountSchema.optional(),
+  accessToken: nonBlankStringSchema,
+  expiresAt: z4.number().finite().optional(),
+  refreshToken: nonBlankStringSchema,
+  refreshTokenExpiresAt: z4.number().finite().optional(),
+  scope: nonBlankStringSchema.optional()
+}).strict();
+var pluginGrantSchema = z4.object({
   access: pluginGrantAccessSchema,
   name: pluginGrantNameSchema,
   reason: nonBlankStringSchema.optional(),
-  requirements: z2.array(nonBlankStringSchema).min(1).optional()
+  requirements: z4.array(nonBlankStringSchema).min(1).optional()
 }).strict();
-var pluginCredentialHeaderTransformSchema = z2.object({
-  domain: z2.string().min(1),
-  headers: z2.record(z2.string(), z2.string()).refine((headers) => Object.keys(headers).length > 0)
+var pluginCredentialHeaderTransformSchema = z4.object({
+  domain: z4.string().min(1),
+  headers: z4.record(z4.string(), z4.string()).refine((headers) => Object.keys(headers).length > 0)
 }).strict();
-var pluginCredentialLeaseSchema = z2.object({
+var pluginCredentialLeaseSchema = z4.object({
   account: pluginProviderAccountSchema.optional(),
   authorization: pluginAuthorizationSchema.optional(),
-  expiresAt: z2.string().refine((value) => Number.isFinite(Date.parse(value))),
-  headerTransforms: z2.array(pluginCredentialHeaderTransformSchema).min(1)
+  expiresAt: z4.string().refine((value) => Number.isFinite(Date.parse(value))),
+  headerTransforms: z4.array(pluginCredentialHeaderTransformSchema).min(1)
 }).strict();
-var pluginCredentialResultSchema = z2.discriminatedUnion("type", [
-  z2.object({
+var pluginCredentialResultSchema = z4.discriminatedUnion("type", [
+  z4.object({
     lease: pluginCredentialLeaseSchema,
-    type: z2.literal("lease")
+    type: z4.literal("lease")
   }).strict(),
-  z2.object({
+  z4.object({
     authorization: pluginAuthorizationSchema.optional(),
     message: nonBlankStringSchema,
-    type: z2.literal("needed")
+    type: z4.literal("needed")
   }).strict(),
-  z2.object({
+  z4.object({
     message: nonBlankStringSchema,
-    type: z2.literal("unavailable")
+    type: z4.literal("unavailable")
   }).strict()
 ]);
 var EgressAuthRequired = class extends Error {
@@ -227,14 +306,19 @@ function defineJuniorPlugin(plugin) {
 export {
   EgressAuthRequired,
   PluginToolInputError,
+  createLocalSource,
+  createSlackSource,
   defineJuniorPlugin,
   destinationSchema,
   dispatchOptionsSchema,
+  getSourceKey,
+  isPrivateSource,
   isSlackDestination,
   localDestinationSchema,
   localRequesterSchema,
   localSourceSchema,
   nonBlankStringSchema,
+  platformSchema,
   pluginAuthorizationSchema,
   pluginCredentialHeaderTransformSchema,
   pluginCredentialLeaseSchema,
@@ -242,9 +326,14 @@ export {
   pluginCredentialSubjectSchema,
   pluginGrantSchema,
   pluginProviderAccountSchema,
+  pluginRunContextSchema,
+  pluginRunTranscriptEntrySchema,
+  pluginStoredTokensSchema,
+  promptMessageSchema,
   requesterSchema,
   slackDestinationSchema,
   slackRequesterSchema,
   slackSourceSchema,
-  sourceSchema
+  sourceSchema,
+  sourceTypeSchema
 };

package/dist/operations.d.ts

@@ -1,5 +1,4 @@
 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";
@@ -36,7 +35,6 @@ export interface StorageMigrationResult {
     skipped?: number;
 }
 export interface StorageMigrationContext extends PluginContext {
-    db: PluginDb;
     state: PluginState;
 }
 export type PluginOperationalTone = "danger" | "good" | "neutral" | "warning";

package/dist/prompt.d.ts

@@ -1,42 +1,22 @@
-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;
+import { z } from "zod";
+import type { Destination, Platform, PluginContext, PluginEmbedder, Requester, Source } from "./context";
+import type { PluginState } from "./state";
+export declare const promptMessageSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+/** Small plugin-owned prompt text block rendered by Junior core. */
+export type PromptMessage = z.output<typeof promptMessageSchema>;
+/** Stable platform context for plugin system prompt guidance. */
+export type SystemPromptContext = Pick<PluginContext, "db" | "log" | "plugin"> & {
+    platform: Platform;
 };
-export interface PluginTaskContext extends PluginContext {
-    id: string;
-    name: string;
-    observation?: {
-        load(): Promise<unknown | undefined>;
-    };
-    payload?: unknown;
+/** Runtime facts available while building plugin user prompt context. */
+export type UserPromptContext = Pick<PluginContext, "db" | "log" | "plugin"> & {
+    conversationId?: string;
+    destination: Destination;
+    embedder: PluginEmbedder;
+    requester?: Requester;
+    source: Source;
     state: PluginState;
-}
-export type PluginTaskHandler = (ctx: PluginTaskContext) => Promise<void> | void;
+    text: string;
+};

package/dist/registration.d.ts

@@ -1,11 +1,20 @@
-import type { PluginDatabaseConfig } from "./database";
+import type { PluginCliDefinition } from "./cli";
 import type { PluginHooks } from "./hooks";
 import type { PluginManifest } from "./manifest";
+import type { PluginTasks } from "./tasks";
+export interface PluginModelConfig {
+    /** Host model family used when no explicit structured model id is configured. */
+    structuredModel?: "default" | "fast";
+    /** Host model id used for this plugin's structured model calls. */
+    structuredModelId?: string;
+}
 export type PluginRegistrationInput = {
-    database?: PluginDatabaseConfig;
+    cli?: PluginCliDefinition;
     hooks?: PluginHooks;
     manifest: PluginManifest;
+    model?: PluginModelConfig;
     packageName?: string;
+    tasks?: PluginTasks;
 };
 export interface PluginRegistration extends PluginRegistrationInput {
 }

package/dist/schemas.d.ts

@@ -1,5 +1,15 @@
 import { z } from "zod";
 export declare const nonBlankStringSchema: z.ZodString;
+/** Runtime platform names supported by plugin public contracts. */
+export declare const platformSchema: z.ZodEnum<{
+    slack: "slack";
+    local: "local";
+}>;
+/** Runtime source visibility visible to plugins. */
+export declare const sourceTypeSchema: z.ZodEnum<{
+    pub: "pub";
+    priv: "priv";
+}>;
 /** Runtime-owned Slack address for routing future work or side effects. */
 export declare const slackDestinationSchema: z.ZodObject<{
     platform: z.ZodLiteral<"slack">;
@@ -25,12 +35,17 @@ export declare const slackSourceSchema: z.ZodObject<{
     platform: z.ZodLiteral<"slack">;
     teamId: z.ZodString;
     channelId: z.ZodString;
+    type: z.ZodEnum<{
+        pub: "pub";
+        priv: "priv";
+    }>;
     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">;
+    type: z.ZodLiteral<"priv">;
     conversationId: z.ZodString;
 }, z.core.$strict>;
 /** Runtime-owned provider-neutral coordinates for the inbound invocation. */
@@ -38,10 +53,15 @@ export declare const sourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     platform: z.ZodLiteral<"slack">;
     teamId: z.ZodString;
     channelId: z.ZodString;
+    type: z.ZodEnum<{
+        pub: "pub";
+        priv: "priv";
+    }>;
     messageTs: z.ZodOptional<z.ZodString>;
     threadTs: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     platform: z.ZodLiteral<"local">;
+    type: z.ZodLiteral<"priv">;
     conversationId: z.ZodString;
 }, z.core.$strict>], "platform">;
 /** Stable user credential subject shape accepted from plugins. */
@@ -99,10 +119,15 @@ export declare const dispatchOptionsSchema: z.ZodObject<{
         platform: z.ZodLiteral<"slack">;
         teamId: z.ZodString;
         channelId: z.ZodString;
+        type: z.ZodEnum<{
+            pub: "pub";
+            priv: "priv";
+        }>;
         messageTs: z.ZodOptional<z.ZodString>;
         threadTs: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         platform: z.ZodLiteral<"local">;
+        type: z.ZodLiteral<"priv">;
         conversationId: z.ZodString;
     }, z.core.$strict>], "platform">;
 }, z.core.$strict>;

package/dist/state.d.ts

@@ -8,13 +8,3 @@ export interface PluginState {
 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;
-    }>>;
-}