@sentry/junior 0.53.0 → 0.55.0

package/dist/chat/logging.d.ts

@@ -0,0 +1,90 @@
+import type { Logger as ChatSdkLogger } from "chat";
+import * as Sentry from "@/chat/sentry";
+import type { AgentTurnUsage } from "@/chat/usage";
+type Primitive = string | number | boolean;
+type AttributeValue = Primitive | string[];
+export type LogAttributes = Record<string, AttributeValue>;
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface EmittedLogRecord {
+    attributes: LogAttributes;
+    body: string;
+    eventName: string;
+    level: LogLevel;
+}
+export interface LogContext {
+    conversationId?: string;
+    platform?: string;
+    requestId?: string;
+    slackThreadId?: string;
+    slackUserId?: string;
+    slackUserName?: string;
+    slackChannelId?: string;
+    runId?: string;
+    actorType?: string;
+    actorId?: string;
+    assistantUserName?: string;
+    modelId?: string;
+    skillName?: string;
+    httpMethod?: string;
+    httpPath?: string;
+    urlFull?: string;
+    userAgent?: string;
+}
+export declare const log: {
+    debug(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
+    info(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
+    warn(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
+    error(eventName: string, attrs?: Record<string, unknown>, body?: string): void;
+    exception(eventName: string, error: unknown, attrs?: Record<string, unknown>, body?: string): string | undefined;
+};
+/** Create a Chat SDK logger that routes records through Junior's logging backend. */
+export declare function createChatSdkLogger(): ChatSdkLogger;
+export declare function withLogContext<T>(context: LogContext, callback: () => Promise<T>): Promise<T>;
+export declare function setLogContext(context: LogContext): void;
+export declare function getLogContextAttributes(): LogAttributes;
+export declare function registerLogRecordSink(sink: (record: EmittedLogRecord) => void): () => void;
+export declare function createLogContextFromRequest(request: Request, context?: Partial<LogContext>): LogContext;
+export declare function toSpanAttributes(context: LogContext): Record<string, string>;
+export declare function setSentryTagsFromContext(context: LogContext): void;
+export declare function setSentryScopeContext(scope: Sentry.Scope, context: LogContext): void;
+/** Capture an error to Sentry and emit an error log record. */
+export declare function captureException(error: unknown, context?: LogContext): void;
+/** Log an info-level structured event. */
+export declare function logInfo(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
+/** Log a warning-level structured event. */
+export declare function logWarn(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
+/** Log an error-level structured event. */
+export declare function logError(eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): void;
+/** Log an error with exception capture; returns the Sentry event ID if available. */
+export declare function logException(error: unknown, eventName: string, context?: LogContext, attributes?: Record<string, unknown>, body?: string): string | undefined;
+/** Set log context and Sentry tags for the current scope. */
+export declare function setTags(context?: LogContext): void;
+/** Create a LogContext from an incoming HTTP request. */
+export declare function createRequestContext(request: Request, context?: Partial<LogContext>): LogContext;
+/** Run a callback within a scoped log context. */
+export declare function withContext<T>(context: LogContext, callback: () => Promise<T>): Promise<T>;
+/** Run a callback within a Sentry span and scoped log context. */
+export declare function withSpan<T>(name: string, op: string, context: LogContext, callback: () => Promise<T>, attributes?: Record<string, unknown>): Promise<T>;
+/** Set attributes on the currently active Sentry span. */
+export declare function setSpanAttributes(attributes: Record<string, unknown>): void;
+/** Set the status of the currently active Sentry span. */
+export declare function setSpanStatus(status: "ok" | "error"): void;
+/** Capture an exception within an isolated Sentry scope. */
+export declare function captureExceptionInScope(error: unknown, context?: LogContext): void;
+/** Return the trace ID from the active Sentry span, if any. */
+export declare function getActiveTraceId(): string | undefined;
+/** Build the static user-facing response for a failed turn. */
+export declare function buildTurnFailureResponse(eventId: string): string;
+/** Serialize an AI model response value into a truncated log attribute. */
+export declare function serializeGenAiAttribute(value: unknown, maxChars?: number): string | undefined;
+/**
+ * Sum pi-ai `Usage` counters across every source into an `AgentTurnUsage`.
+ *
+ * Callers pass every assistant message produced during a turn so the result
+ * reflects the aggregate usage for the entire turn rather than a single model
+ * call. Sources without a recognized usage record contribute nothing.
+ */
+export declare function extractGenAiUsageSummary(...sources: unknown[]): AgentTurnUsage;
+/** Extract GenAI token usage attributes from AI provider usage metadata for tracing. */
+export declare function extractGenAiUsageAttributes(...sources: unknown[]): Partial<Record<"gen_ai.usage.input_tokens" | "gen_ai.usage.output_tokens" | "gen_ai.usage.cache_read.input_tokens" | "gen_ai.usage.cache_creation.input_tokens", number>>;
+export {};

package/dist/chat/mcp/auth-store.d.ts

@@ -0,0 +1,41 @@
+import type { OAuthClientInformationMixed, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { ThreadArtifactsState } from "@/chat/state/artifacts";
+export interface McpAuthSessionState {
+    authSessionId: string;
+    provider: string;
+    userId: string;
+    conversationId: string;
+    sessionId: string;
+    userMessage: string;
+    channelId?: string;
+    threadTs?: string;
+    toolChannelId?: string;
+    configuration?: Record<string, unknown>;
+    artifactState?: ThreadArtifactsState;
+    authorizationUrl?: string;
+    codeVerifier?: string;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export interface McpStoredOAuthCredentials {
+    clientInformation?: OAuthClientInformationMixed;
+    discoveryState?: OAuthDiscoveryState;
+    tokens?: OAuthTokens;
+}
+export interface McpServerSessionState {
+    sessionId: string;
+    updatedAtMs: number;
+}
+export declare function getMcpAuthSession(authSessionId: string): Promise<McpAuthSessionState | undefined>;
+export declare function putMcpAuthSession(session: McpAuthSessionState, ttlMs?: number): Promise<void>;
+export declare function patchMcpAuthSession(authSessionId: string, patch: Partial<McpAuthSessionState>): Promise<McpAuthSessionState>;
+export declare function deleteMcpAuthSession(authSessionId: string): Promise<void>;
+export declare function deleteMcpAuthSessionsForUserProvider(userId: string, provider: string): Promise<void>;
+export declare function getLatestMcpAuthSessionForUserProvider(userId: string, provider: string): Promise<McpAuthSessionState | undefined>;
+export declare function getMcpStoredOAuthCredentials(userId: string, provider: string): Promise<McpStoredOAuthCredentials | undefined>;
+export declare function putMcpStoredOAuthCredentials(userId: string, provider: string, value: McpStoredOAuthCredentials, ttlMs?: number): Promise<void>;
+export declare function deleteMcpStoredOAuthCredentials(userId: string, provider: string): Promise<void>;
+export declare function getMcpServerSessionId(userId: string, provider: string): Promise<string | undefined>;
+export declare function putMcpServerSessionId(userId: string, provider: string, sessionId: string, ttlMs?: number): Promise<void>;
+export declare function deleteMcpServerSessionId(userId: string, provider: string): Promise<void>;

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/agent-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { AgentPluginRequester, JuniorPlugin } from "@sentry/junior-plugin-api";
+import type { ToolDefinition } from "@/chat/tools/definition";
+import type { ToolRuntimeContext } from "@/chat/tools/types";
+import type { SandboxInstance } from "@/chat/sandbox/workspace";
+/** Signal that a trusted plugin intentionally denied a tool execution. */
+export declare class AgentPluginHookDeniedError extends Error {
+    constructor(message: string);
+}
+export interface ToolHookInput {
+    input: Record<string, unknown>;
+    name: string;
+}
+export interface ToolHookResult {
+    env: Record<string, string>;
+    input: Record<string, unknown>;
+}
+export interface AgentPluginHookRunner {
+    beforeToolExecute(input: ToolHookInput): Promise<ToolHookResult>;
+    prepareSandbox(sandbox: SandboxInstance): Promise<void>;
+}
+/** Validate trusted plugin identity before it can affect process-wide hooks. */
+export declare function validateAgentPlugins(plugins: JuniorPlugin[]): void;
+/** Replace trusted agent plugins and return the previous list for rollback. */
+export declare function setAgentPlugins(plugins: JuniorPlugin[]): JuniorPlugin[];
+/** Return the current trusted agent plugins without exposing mutable state. */
+export declare function getAgentPlugins(): JuniorPlugin[];
+/** Collect turn-scoped tools exposed by trusted plugins. */
+export declare function getAgentPluginTools(context: ToolRuntimeContext): Record<string, ToolDefinition<any>>;
+/** Create one runner over trusted agent plugins registered by the app. */
+export declare function createAgentPluginHookRunner(input?: {
+    requester?: AgentPluginRequester;
+}): AgentPluginHookRunner;

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/logging.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPluginLogger } from "@sentry/junior-plugin-api";
+/** Create the host logger exposed to trusted plugin hooks. */
+export declare function createAgentPluginLogger(plugin: string): AgentPluginLogger;

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/state.d.ts

@@ -0,0 +1,3 @@
+import type { AgentPluginState } from "@sentry/junior-plugin-api";
+/** Create a durable state namespace scoped to one trusted plugin. */
+export declare function createPluginState(plugin: string): AgentPluginState;