@sentry/junior 0.52.0 → 0.54.0

package/dist/chat/mcp/client.d.ts

@@ -0,0 +1,34 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { PluginDefinition } from "@/chat/plugins/types";
+type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
+type ToolCallResult = Awaited<ReturnType<Client["callTool"]>>;
+export declare class McpAuthorizationRequiredError extends Error {
+    readonly provider: string;
+    constructor(provider: string, message: string);
+}
+export interface PluginMcpClientOptions {
+    authProvider?: OAuthClientProvider;
+    fetch?: typeof fetch;
+}
+export declare class PluginMcpClient {
+    private readonly plugin;
+    private readonly options;
+    private client?;
+    private lastAttemptedTransportSessionId?;
+    private transport?;
+    private listedTools?;
+    constructor(plugin: PluginDefinition, options?: PluginMcpClientOptions);
+    listTools(): Promise<ListedTool[]>;
+    callTool(name: string, args: Record<string, unknown> | undefined): Promise<ToolCallResult>;
+    close(): Promise<void>;
+    private withSessionRecovery;
+    private getClient;
+    private wrapAuth;
+    private shouldResetMissingSession;
+    private disposeClient;
+    private getStoredTransportSessionId;
+    private clearStoredTransportSessionId;
+    private syncTransportSessionId;
+}
+export type { ListedTool as PluginMcpListedTool, ToolCallResult as PluginMcpToolCallResult, };

package/dist/chat/mcp/errors.d.ts

@@ -0,0 +1,8 @@
+/** Thrown when an MCP tool returns an error result. */
+export declare class McpToolError extends Error {
+    constructor(message: string);
+}
+/** Return the OpenTelemetry error.type value for MCP-aware tool failures. */
+export declare function getMcpAwareErrorType(error: unknown, fallback: string): string;
+/** Return the display-safe error message for MCP-aware tool failures. */
+export declare function getMcpAwareErrorMessage(error: unknown): string;

package/dist/chat/mcp/oauth-provider.d.ts

@@ -0,0 +1,27 @@
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { OAuthClientProvider, OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
+import { type McpAuthSessionState } from "./auth-store";
+export declare class StateBackedMcpOAuthClientProvider implements OAuthClientProvider {
+    readonly authSessionId: string;
+    private readonly callbackUrl;
+    private readonly sessionContext?;
+    readonly clientMetadata: OAuthClientMetadata;
+    constructor(authSessionId: string, callbackUrl: string, sessionContext?: Omit<McpAuthSessionState, "authSessionId" | "authorizationUrl" | "codeVerifier" | "createdAtMs" | "updatedAtMs"> | undefined);
+    get redirectUrl(): string;
+    state(): Promise<string>;
+    clientInformation(): Promise<OAuthClientInformationMixed | undefined>;
+    saveClientInformation(clientInformation: OAuthClientInformationMixed): Promise<void>;
+    tokens(): Promise<OAuthTokens | undefined>;
+    saveTokens(tokens: OAuthTokens): Promise<void>;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    saveCodeVerifier(codeVerifier: string): Promise<void>;
+    codeVerifier(): Promise<string>;
+    saveDiscoveryState(state: OAuthDiscoveryState): Promise<void>;
+    discoveryState(): Promise<OAuthDiscoveryState | undefined>;
+    invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): Promise<void>;
+    getMcpServerSessionId(): Promise<string | undefined>;
+    saveMcpServerSessionId(sessionId: string | undefined): Promise<void>;
+    private getCredentialContext;
+    private ensureSession;
+    private requireSession;
+}

package/dist/chat/mcp/oauth.d.ts

@@ -0,0 +1,17 @@
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import { type McpAuthSessionState } from "./auth-store";
+import { StateBackedMcpOAuthClientProvider } from "./oauth-provider";
+export declare function getMcpOAuthCallbackPath(provider: string): string;
+export declare function createMcpOAuthClientProvider(input: {
+    provider: string;
+    conversationId: string;
+    sessionId: string;
+    userId: string;
+    userMessage: string;
+    channelId?: string;
+    threadTs?: string;
+    toolChannelId?: string;
+    configuration?: Record<string, unknown>;
+    artifactState?: ThreadArtifactsState;
+}): Promise<StateBackedMcpOAuthClientProvider>;
+export declare function finalizeMcpAuthorization(provider: string, authSessionId: string, authorizationCode: string): Promise<McpAuthSessionState>;

package/dist/chat/mcp/tool-manager.d.ts

@@ -0,0 +1,60 @@
+import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { SkillMetadata } from "@/chat/skills";
+import type { PluginDefinition } from "@/chat/plugins/types";
+import { McpAuthorizationRequiredError, type PluginMcpToolCallResult } from "./client";
+export interface McpToolManagerOptions {
+    authProviderFactory?: (plugin: PluginDefinition) => OAuthClientProvider | undefined | Promise<OAuthClientProvider | undefined>;
+    fetch?: typeof fetch;
+    onAuthorizationRequired?: (provider: string, error: McpAuthorizationRequiredError) => Promise<boolean | void> | boolean | void;
+}
+export interface ManagedMcpToolResult {
+    content: Array<TextContent | ImageContent>;
+    details: {
+        provider: string;
+        tool: string;
+        rawResult: PluginMcpToolCallResult;
+    };
+}
+export interface ManagedMcpToolDescriptor {
+    name: string;
+    rawName: string;
+    title?: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    annotations?: Record<string, unknown>;
+    provider: string;
+}
+type ActiveMcpSkillScope = Pick<SkillMetadata, "pluginProvider">;
+type ActiveMcpSkill = Pick<SkillMetadata, "name" | "pluginProvider">;
+export interface ManagedMcpTool extends ManagedMcpToolDescriptor {
+    execute: (args: Record<string, unknown>) => Promise<ManagedMcpToolResult>;
+}
+export declare class McpToolManager {
+    private readonly options;
+    private readonly pluginsByProvider;
+    private readonly activeProviders;
+    private readonly authorizationPendingProviders;
+    private readonly clientsByProvider;
+    private readonly toolsByProvider;
+    constructor(plugins: PluginDefinition[], options?: McpToolManagerOptions);
+    getActiveProviders(): string[];
+    activateForSkill(skill: ActiveMcpSkill): Promise<boolean>;
+    activateProvider(provider: string): Promise<boolean>;
+    close(): Promise<void>;
+    getActiveToolCatalog(skills: ActiveMcpSkillScope[], options?: {
+        provider?: string;
+    }): ManagedMcpToolDescriptor[];
+    private filterListedTools;
+    private getClient;
+    private toManagedTool;
+    private handleAuthorizationRequired;
+    /** Return all active ManagedMcpTool objects for the given skill scope. */
+    getResolvedActiveTools(skills: ActiveMcpSkillScope[], options?: {
+        provider?: string;
+    }): ManagedMcpTool[];
+    private resolveProviderTools;
+    private toToolDescriptor;
+}
+export {};

package/dist/chat/oauth-flow.d.ts

@@ -0,0 +1,45 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+type PrivateDeliveryResult = "in_context" | "fallback_dm" | false;
+export type OAuthStatePayload = {
+    userId: string;
+    provider: string;
+    channelId?: string;
+    threadTs?: string;
+    pendingMessage?: string;
+    configuration?: Record<string, unknown>;
+    resumeConversationId?: string;
+    resumeSessionId?: string;
+};
+type OAuthFlowInput = {
+    requesterId: string;
+    channelId?: string;
+    threadTs?: string;
+    userMessage?: string;
+    channelConfiguration?: ChannelConfigurationService;
+    activeSkillName?: string;
+    resumeConversationId?: string;
+    resumeSessionId?: string;
+};
+/** Capitalize the first letter of a provider name for display. */
+export declare function formatProviderLabel(provider: string): string;
+/** Resolve the public base URL from environment variables (JUNIOR_BASE_URL or Vercel). */
+export declare function resolveBaseUrl(): string | undefined;
+/**
+ * Authorization links must only be visible to the requesting user.
+ * Try in-context private delivery first, then fall back to a DM.
+ */
+export declare function deliverPrivateMessage(input: {
+    channelId?: string;
+    threadTs?: string;
+    userId: string;
+    text: string;
+}): Promise<PrivateDeliveryResult>;
+/** Initiate an OAuth authorization code flow for a provider and deliver the auth link to the user. */
+export declare function startOAuthFlow(provider: string, input: OAuthFlowInput): Promise<{
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    delivery: PrivateDeliveryResult;
+}>;
+export {};

package/dist/chat/optional-string.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Normalize optional env-style strings so blank values do not masquerade as
+ * configured inputs.
+ */
+export declare function toOptionalTrimmed(value: string | undefined): string | undefined;

package/dist/chat/pi/client.d.ts

@@ -0,0 +1,49 @@
+import { type Message, type Model, type ThinkingLevel } from "@earendil-works/pi-ai";
+import type { ZodTypeAny, z } from "zod";
+export declare const GEN_AI_PROVIDER_NAME: "vercel-ai-gateway";
+export declare const MISSING_GATEWAY_CREDENTIALS_ERROR = "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)";
+/**
+ * Resolve the documented AI Gateway env credentials for the paths that need
+ * the bearer token string directly.
+ */
+export declare function getGatewayApiKey(): string | undefined;
+/**
+ * Let pi-ai read AI_GATEWAY_API_KEY from env itself and only override the
+ * token when auth comes from VERCEL_OIDC_TOKEN.
+ */
+export declare function getPiGatewayApiKeyOverride(): string | undefined;
+/**
+ * Look up a gateway model by id. Throws `Unknown AI Gateway model id: …` if
+ * the id is not in pi-ai's registry — callers at the config boundary can use
+ * this to fail fast at startup instead of mid-turn.
+ */
+export declare function resolveGatewayModel(modelId: string): Model<any>;
+/** Execute a direct chat completion inside a dedicated `gen_ai.chat` span. */
+export declare function completeText(params: {
+    modelId: string;
+    system?: string;
+    messages: Message[];
+    thinkingLevel?: ThinkingLevel;
+    temperature?: number;
+    maxTokens?: number;
+    signal?: AbortSignal;
+    metadata?: Record<string, unknown>;
+}): Promise<{
+    message: import("@earendil-works/pi-ai").AssistantMessage;
+    text: string;
+}>;
+/** Execute a schema-constrained completion using the traced text path above. */
+export declare function completeObject<TSchema extends ZodTypeAny>(params: {
+    modelId: string;
+    schema: TSchema;
+    system?: string;
+    prompt: string;
+    thinkingLevel?: ThinkingLevel;
+    temperature?: number;
+    maxTokens?: number;
+    signal?: AbortSignal;
+    metadata?: Record<string, unknown>;
+}): Promise<{
+    object: z.infer<TSchema>;
+    text: string;
+}>;

package/dist/chat/pi/messages.d.ts

@@ -0,0 +1,3 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+/** Durable Pi transcript message stored across turns. */
+export type PiMessage = AgentMessage;

package/dist/chat/pi/traced-stream.d.ts

@@ -0,0 +1,9 @@
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+/**
+ * Wraps pi-ai's `streamSimple` so each LLM call inside a pi-agent-core agent
+ * loop produces its own `gen_ai.chat` Sentry span. The returned function is
+ * passed to `new Agent({ streamFn: ... })` and runs once per loop iteration.
+ *
+ * The base argument exists so tests can inject a stub stream function.
+ */
+export declare function createTracedStreamFn(base?: StreamFn): StreamFn;

package/dist/chat/plugins/auth/api-headers-broker.d.ts

@@ -0,0 +1,6 @@
+import type { CredentialBroker, CredentialHeaderTransform } from "@/chat/credentials/broker";
+import type { PluginManifest } from "@/chat/plugins/types";
+/** Resolve plugin-level API headers into sandbox header transforms. */
+export declare function resolveApiHeaderTransforms(manifest: PluginManifest): CredentialHeaderTransform[];
+/** Issue host-managed API header transforms backed by deployment env vars. */
+export declare function createApiHeadersBroker(manifest: PluginManifest): CredentialBroker;

package/dist/chat/plugins/auth/auth-token-placeholder.d.ts

@@ -0,0 +1,3 @@
+import type { GitHubAppCredentials, OAuthBearerCredentials } from "../types";
+/** Resolve the non-secret sandbox token placeholder for token-backed credentials. */
+export declare function resolveAuthTokenPlaceholder(credentials: OAuthBearerCredentials | GitHubAppCredentials): string;

package/dist/chat/plugins/auth/github-app-broker.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialBroker } from "@/chat/credentials/broker";
+import type { GitHubAppCredentials, PluginManifest } from "../types";
+/** Create a broker that keeps GitHub App tokens on the host while authorizing provider traffic. */
+export declare function createGitHubAppBroker(manifest: PluginManifest, credentials: GitHubAppCredentials): CredentialBroker;

package/dist/chat/plugins/auth/oauth-bearer-broker.d.ts

@@ -0,0 +1,6 @@
+import type { CredentialBroker } from "@/chat/credentials/broker";
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+import type { OAuthBearerCredentials, PluginManifest } from "../types";
+export declare function createOAuthBearerBroker(manifest: PluginManifest, credentials: OAuthBearerCredentials, deps: {
+    userTokenStore: UserTokenStore;
+}): CredentialBroker;

package/dist/chat/plugins/auth/oauth-request.d.ts

@@ -0,0 +1,18 @@
+type OAuthTokenRequestInput = {
+    clientId: string;
+    clientSecret: string;
+    payload: Record<string, string>;
+    tokenAuthMethod?: "body" | "basic";
+    tokenExtraHeaders?: Record<string, string>;
+};
+export declare function buildOAuthTokenRequest(input: OAuthTokenRequestInput): {
+    headers: Record<string, string>;
+    body: BodyInit;
+};
+export declare function parseOAuthTokenResponse(data: Record<string, unknown>, fallbackScope?: string): {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt?: number;
+    scope?: string;
+};
+export {};

package/dist/chat/plugins/command-env.d.ts

@@ -0,0 +1,3 @@
+import type { PluginManifest } from "@/chat/plugins/types";
+/** Resolve non-secret sandbox command env declared by a plugin manifest. */
+export declare function resolvePluginCommandEnv(manifest: PluginManifest): Record<string, string>;

package/dist/chat/plugins/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { PluginConfig, PluginManifest } from "./types";
+/** Parse one plugin manifest after applying install-level plugin config. */
+export declare function parsePluginManifest(raw: string, dir: string, config?: PluginConfig): PluginManifest;

package/dist/chat/plugins/package-discovery.d.ts

@@ -0,0 +1,14 @@
+export interface InstalledPluginPackageContent {
+    packageNames: string[];
+    manifestRoots: string[];
+    skillRoots: string[];
+    tracingIncludes: string[];
+}
+/** Normalize and validate configured plugin package names. */
+export declare function normalizePluginPackageNames(packageNames: unknown): string[];
+export interface DiscoverInstalledPluginPackageContentOptions {
+    nodeModulesDirs?: string[];
+    packageNames?: unknown;
+}
+/** Discover plugin package content from explicitly declared package names. */
+export declare function discoverInstalledPluginPackageContent(cwd?: string, options?: DiscoverInstalledPluginPackageContentOptions): InstalledPluginPackageContent;

package/dist/chat/plugins/registry.d.ts

@@ -0,0 +1,23 @@
+import type { CapabilityProviderDefinition } from "@/chat/capabilities/catalog";
+import type { CredentialBroker } from "@/chat/credentials/broker";
+import { type InstalledPluginPackageContent } from "./package-discovery";
+import type { PluginBrokerDeps, PluginConfig, PluginDefinition, OAuthProviderConfig, PluginRuntimeDependency, PluginRuntimePostinstallCommand } from "./types";
+/** Set install-wide plugin configuration and return the previous value for rollback. */
+export declare function setPluginConfig(config: PluginConfig | undefined): PluginConfig | undefined;
+/** Return installed plugin package content from the active plugin configuration. */
+export declare function getPluginPackageContent(): InstalledPluginPackageContent;
+/** Return the current plugin catalog signature used for cache invalidation. */
+export declare function getPluginCatalogSignature(): string;
+export declare function getPluginCapabilityProviders(): CapabilityProviderDefinition[];
+export declare function getPluginProviders(): PluginDefinition[];
+export declare function getPluginMcpProviders(): PluginDefinition[];
+export declare function getPluginRuntimeDependencies(): PluginRuntimeDependency[];
+export declare function getPluginRuntimePostinstall(): PluginRuntimePostinstallCommand[];
+export declare function getPluginOAuthConfig(provider: string): OAuthProviderConfig | undefined;
+export declare function getPluginSkillRoots(): string[];
+export declare function getPluginForSkillPath(skillPath: string): PluginDefinition | undefined;
+export declare function getPluginDefinition(provider: string): PluginDefinition | undefined;
+export declare function isPluginProvider(provider: string): boolean;
+export declare function isPluginCapability(capability: string): boolean;
+export declare function isPluginConfigKey(key: string): boolean;
+export declare function createPluginBroker(provider: string, deps: PluginBrokerDeps): CredentialBroker;

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

@@ -0,0 +1,146 @@
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+export interface PluginOAuthConfig {
+    clientIdEnv: string;
+    clientSecretEnv: string;
+    authorizeEndpoint: string;
+    tokenEndpoint: string;
+    scope?: string;
+    authorizeParams?: Record<string, string>;
+    tokenAuthMethod?: "body" | "basic";
+    tokenExtraHeaders?: Record<string, string>;
+}
+export interface OAuthProviderConfig extends PluginOAuthConfig {
+    callbackPath: string;
+}
+export interface OAuthBearerCredentials {
+    type: "oauth-bearer";
+    domains: string[];
+    apiHeaders?: Record<string, string>;
+    authTokenEnv: string;
+    authTokenPlaceholder?: string;
+}
+export interface GitHubAppCredentials {
+    type: "github-app";
+    domains: string[];
+    apiHeaders?: Record<string, string>;
+    authTokenEnv: string;
+    authTokenPlaceholder?: string;
+    appIdEnv: string;
+    privateKeyEnv: string;
+    installationIdEnv: string;
+}
+export type PluginCredentials = OAuthBearerCredentials | GitHubAppCredentials;
+export interface PluginNpmRuntimeDependency {
+    type: "npm";
+    package: string;
+    version: string;
+}
+export interface PluginSystemRuntimeDependency {
+    type: "system";
+    package: string;
+}
+export interface PluginSystemRuntimeDependencyFromUrl {
+    type: "system";
+    url: string;
+    sha256: string;
+}
+export type PluginRuntimeDependency = PluginNpmRuntimeDependency | PluginSystemRuntimeDependency | PluginSystemRuntimeDependencyFromUrl;
+export interface PluginRuntimePostinstallCommand {
+    cmd: string;
+    args?: string[];
+    sudo?: boolean;
+}
+export interface PluginMcpHttpConfig {
+    transport: "http";
+    url: string;
+    headers?: Record<string, string>;
+    allowedTools?: string[];
+}
+export type PluginMcpConfig = PluginMcpHttpConfig;
+export interface PluginEnvVarDeclaration {
+    default?: string;
+}
+export interface PluginManifest {
+    name: string;
+    description: string;
+    capabilities: string[];
+    configKeys: string[];
+    domains?: string[];
+    apiHeaders?: Record<string, string>;
+    commandEnv?: Record<string, string>;
+    envVars?: Record<string, PluginEnvVarDeclaration>;
+    credentials?: PluginCredentials;
+    runtimeDependencies?: PluginRuntimeDependency[];
+    runtimePostinstall?: PluginRuntimePostinstallCommand[];
+    mcp?: PluginMcpConfig;
+    oauth?: PluginOAuthConfig;
+    target?: {
+        type: string;
+        configKey: string;
+        commandFlags?: string[];
+    };
+}
+type PluginRuntimeDependencyConfig = {
+    type: "npm";
+    package: string;
+    version?: string;
+} | {
+    type: "system";
+    package: string;
+} | {
+    type: "system";
+    url: string;
+    sha256: string;
+};
+interface PluginOAuthConfigPatch extends Omit<Partial<PluginOAuthConfig>, "authorizeParams" | "tokenExtraHeaders"> {
+    authorizeParams?: Record<string, string | null> | null;
+    tokenExtraHeaders?: Record<string, string | null> | null;
+}
+/** Install-level changes applied to one plugin manifest before validation. */
+export interface PluginManifestConfig {
+    description?: string;
+    capabilities?: string[];
+    configKeys?: string[];
+    domains?: string[] | null;
+    apiHeaders?: Record<string, string | null> | null;
+    commandEnv?: Record<string, string | null> | null;
+    envVars?: Record<string, PluginEnvVarDeclaration | null> | null;
+    credentials?: {
+        type?: "oauth-bearer" | "github-app";
+        domains?: string[];
+        apiHeaders?: Record<string, string | null> | null;
+        authTokenEnv?: string;
+        authTokenPlaceholder?: string | null;
+        appIdEnv?: string;
+        privateKeyEnv?: string;
+        installationIdEnv?: string;
+    } | null;
+    runtimeDependencies?: PluginRuntimeDependencyConfig[] | null;
+    runtimePostinstall?: PluginRuntimePostinstallCommand[] | null;
+    mcp?: {
+        transport?: "http";
+        url?: string;
+        headers?: Record<string, string | null> | null;
+        allowedTools?: string[] | null;
+    } | null;
+    oauth?: PluginOAuthConfigPatch | null;
+    target?: {
+        type?: string;
+        configKey?: string;
+        commandFlags?: string[] | null;
+    } | null;
+}
+/** Install-level plugin package list and manifest configuration. */
+export interface PluginConfig {
+    packages?: string[];
+    manifests?: Record<string, PluginManifestConfig>;
+}
+export interface PluginBrokerDeps {
+    userTokenStore: UserTokenStore;
+}
+export interface PluginDefinition {
+    manifest: PluginManifest;
+    dir: string;
+    skillsDir: string;
+}
+export {};

package/dist/chat/prompt.d.ts

@@ -0,0 +1,39 @@
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+import type { Skill, SkillMetadata, SkillInvocation } from "@/chat/skills";
+import type { ActiveMcpCatalogSummary } from "@/chat/tools/skill/mcp-tool-summary";
+export declare const JUNIOR_PERSONALITY: string;
+export declare const JUNIOR_WORLD: string | null;
+interface ToolPromptContext {
+    name: string;
+    promptGuidelines?: string[];
+    promptSnippet?: string;
+}
+type TurnContextPromptInput = {
+    availableSkills: SkillMetadata[];
+    activeSkills: Skill[];
+    activeMcpCatalogs?: ActiveMcpCatalogSummary[];
+    toolGuidance?: ToolPromptContext[];
+    runtime?: {
+        conversationId?: string;
+        traceId?: string;
+    };
+    invocation: SkillInvocation | null;
+    requester?: {
+        userName?: string;
+        fullName?: string;
+        userId?: string;
+    };
+    artifactState?: ThreadArtifactsState;
+    configuration?: Record<string, unknown>;
+    /**
+     * Whether this turn is a fresh prompt or a resume from a prior checkpoint
+     * (OAuth pause or timeout-resume). Surfaced in <context> so the model knows
+     * it is continuing rather than starting fresh.
+     */
+    turnState?: "fresh" | "resumed";
+};
+/** Return byte-stable platform instructions shared by every conversation and turn. */
+export declare function buildSystemPrompt(): string;
+/** Build volatile runtime context that belongs in the user turn, not the system prompt. */
+export declare function buildTurnContextPrompt(params: TurnContextPromptInput): string;
+export {};

package/dist/chat/queue/thread-message-dispatcher.d.ts

@@ -0,0 +1,33 @@
+import type { Message, Thread } from "chat";
+import type { SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import { downloadPrivateSlackFile as downloadPrivateSlackFileImpl } from "@/chat/slack/client";
+export type ThreadMessageKind = "new_mention" | "subscribed_message";
+export interface ThreadMessageDispatchArgs {
+    beforeFirstResponsePost?: () => Promise<void>;
+    kind: ThreadMessageKind;
+    message: Message;
+    thread: Thread;
+}
+export type ThreadMessageRuntime = Pick<SlackTurnRuntime<unknown>, "handleNewMention" | "handleSubscribedMessage">;
+export type ThreadMessageDispatcher = (args: ThreadMessageDispatchArgs) => Promise<void>;
+export interface CreateThreadMessageDispatcherOptions {
+    downloadPrivateSlackFile?: typeof downloadPrivateSlackFileImpl;
+    runtime: ThreadMessageRuntime;
+}
+/**
+ * Attach Slack private-file download functions to deserialized attachments.
+ *
+ * The Chat SDK's `concurrency: "queue"` strategy serializes queued messages
+ * via `Message.toJSON()`, which strips `fetchData` (a function) and `data`
+ * (a Buffer). When dequeued, attachments have a `url` but no fetcher.
+ * This re-attaches a bot-token-auth'd download callback.
+ *
+ * No-ops when `fetchData` is already present, so safe to call unconditionally.
+ */
+export declare function rehydrateAttachmentFetchers(message: {
+    attachments: Array<{
+        fetchData?: unknown;
+        url?: string;
+    }>;
+}, downloadPrivateSlackFile?: typeof downloadPrivateSlackFileImpl): void;
+export declare function createThreadMessageDispatcher(options: CreateThreadMessageDispatcherOptions): ThreadMessageDispatcher;