@sentry/junior 0.52.0 → 0.54.0

package/dist/build/copy-build-content.d.ts

@@ -0,0 +1,4 @@
+/** Copy app directory and plugin manifests into the server output. */
+export declare function copyAppAndPluginContent(cwd: string, serverRoot: string, packageNames?: unknown): void;
+/** Copy extra file patterns into server output for files the bundler cannot trace. */
+export declare function copyIncludedFiles(cwd: string, serverRoot: string, patterns?: unknown): void;

package/dist/build/glob-to-regex.d.ts

@@ -0,0 +1,2 @@
+/** Convert a simple file glob (supporting `*` wildcards) into a RegExp. */
+export declare function globToRegex(pattern: string): RegExp;

package/dist/build/rolldown-workarounds.d.ts

@@ -0,0 +1,14 @@
+import type { Nitro } from "nitro/types";
+/**
+ * Override rolldown's treeshake config so that module side effects survive
+ * bundling.
+ *
+ * pi-ai registers API providers via a top-level side-effect in
+ * register-builtins.js. Nitro's default moduleSideEffects whitelist only
+ * includes unenv polyfills, so rolldown tree-shakes the registration call
+ * and the apiProviderRegistry Map stays empty at runtime.
+ *
+ * TODO(upstream): Track https://github.com/nitrojs/nitro/issues/XXXX for
+ * native moduleSideEffects configuration support.
+ */
+export declare function applyRolldownTreeshakeWorkaround(nitro: Nitro): void;

package/dist/build/virtual-config.d.ts

@@ -0,0 +1,4 @@
+import type { Nitro } from "nitro/types";
+import type { PluginConfig } from "@/chat/plugins/types";
+/** Inject a virtual module so createApp() can read the plugin list at runtime. */
+export declare function injectVirtualConfig(nitro: Nitro, plugins?: PluginConfig): void;

package/dist/chat/app/factory.d.ts

@@ -0,0 +1,10 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { type AssistantLifecycleEvent, type SlackTurnRuntime } from "@/chat/runtime/slack-runtime";
+import type { JuniorRuntimeServiceOverrides } from "@/chat/app/services";
+import { type PreparedTurnState } from "@/chat/runtime/turn-preparation";
+export interface CreateSlackRuntimeOptions {
+    getSlackAdapter: () => SlackAdapter;
+    now?: () => number;
+    services?: JuniorRuntimeServiceOverrides;
+}
+export declare function createSlackRuntime(options: CreateSlackRuntimeOptions): SlackTurnRuntime<PreparedTurnState, AssistantLifecycleEvent>;

package/dist/chat/app/production.d.ts

@@ -0,0 +1,6 @@
+import type { SlackAdapter } from "@chat-adapter/slack";
+import { JuniorChat } from "@/chat/ingress/junior-chat";
+/** Return the lazily initialized production chat app. */
+export declare function getProductionBot(): JuniorChat<{
+    slack: SlackAdapter;
+}>;

package/dist/chat/app/services.d.ts

@@ -0,0 +1,17 @@
+import { type ConversationMemoryDeps, type ConversationMemoryService } from "@/chat/services/conversation-memory";
+import { type SubscribedReplyPolicy, type SubscribedReplyPolicyDeps } from "@/chat/services/subscribed-reply-policy";
+import type { ReplyExecutorServices } from "@/chat/runtime/reply-executor";
+import { type VisionContextDeps, type VisionContextService } from "@/chat/services/vision-context";
+export interface JuniorRuntimeServices {
+    conversationMemory: ConversationMemoryService;
+    replyExecutor: ReplyExecutorServices;
+    subscribedReplyPolicy: SubscribedReplyPolicy;
+    visionContext: VisionContextService;
+}
+export interface JuniorRuntimeServiceOverrides {
+    conversationMemory?: Partial<ConversationMemoryDeps>;
+    replyExecutor?: Partial<Omit<ReplyExecutorServices, "generateThreadTitle">>;
+    subscribedReplyPolicy?: Partial<SubscribedReplyPolicyDeps>;
+    visionContext?: Partial<VisionContextDeps>;
+}
+export declare function createJuniorRuntimeServices(overrides?: JuniorRuntimeServiceOverrides): JuniorRuntimeServices;

package/dist/chat/capabilities/catalog.d.ts

@@ -0,0 +1,16 @@
+export interface CapabilityProviderTargetDefinition {
+    type: string;
+    configKey: string;
+    commandFlags?: string[];
+}
+export interface CapabilityProviderDefinition {
+    provider: string;
+    capabilities: string[];
+    configKeys: string[];
+    target?: CapabilityProviderTargetDefinition;
+}
+export declare function getCapabilityProvider(capability: string): CapabilityProviderDefinition | undefined;
+export declare function isKnownCapability(capability: string): boolean;
+export declare function listCapabilityProviders(): CapabilityProviderDefinition[];
+/** Log the capability catalog contents once at startup. */
+export declare function logCapabilityCatalogLoadedOnce(): void;

package/dist/chat/capabilities/factory.d.ts

@@ -0,0 +1,10 @@
+import type { CredentialLease } from "@/chat/credentials/broker";
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+/** Create the user token store used by OAuth-backed credential brokers. */
+export declare function createUserTokenStore(): UserTokenStore;
+/** Issue one provider credential lease for host-side sandbox egress proxying. */
+export declare function issueProviderCredentialLease(input: {
+    provider: string;
+    requesterId: string;
+    reason: string;
+}): Promise<CredentialLease>;

package/dist/chat/capabilities/jr-rpc-command.d.ts

@@ -0,0 +1,26 @@
+import type { ChannelConfigurationService } from "@/chat/configuration/types";
+import type { Skill } from "@/chat/skills";
+type JrRpcDeps = {
+    activeSkill: Skill | null;
+    channelConfiguration?: ChannelConfigurationService;
+    requesterId?: string;
+    onConfigurationValueChanged?: (key: string, value: unknown | undefined) => void;
+};
+export declare function maybeExecuteJrRpcCustomCommand(command: string, deps: JrRpcDeps): Promise<{
+    handled: false;
+} | {
+    handled: true;
+    result: {
+        ok: boolean;
+        command: string;
+        cwd: string;
+        exit_code: number;
+        signal: null;
+        timed_out: boolean;
+        stdout: string;
+        stderr: string;
+        stdout_truncated: boolean;
+        stderr_truncated: boolean;
+    };
+}>;
+export {};

package/dist/chat/capabilities/router.d.ts

@@ -0,0 +1,19 @@
+import type { CredentialBroker, CredentialLease } from "@/chat/credentials/broker";
+export interface CredentialRouter {
+    issue(input: {
+        provider: string;
+        reason: string;
+        requesterId?: string;
+    }): Promise<CredentialLease>;
+}
+export declare class ProviderCredentialRouter implements CredentialRouter {
+    private readonly brokersByProvider;
+    constructor(input: {
+        brokersByProvider: Record<string, CredentialBroker>;
+    });
+    issue(input: {
+        provider: string;
+        reason: string;
+        requesterId?: string;
+    }): Promise<CredentialLease>;
+}

package/dist/chat/coerce.d.ts

@@ -0,0 +1,6 @@
+/** Narrow an unknown value to a non-empty string, or undefined. */
+export declare function toOptionalString(value: unknown): string | undefined;
+/** Narrow an unknown value to a finite number, or undefined. */
+export declare function toOptionalNumber(value: unknown): number | undefined;
+/** Type-guard: true when value is a non-null object (usable as Record). */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/chat/config.d.ts

@@ -0,0 +1,46 @@
+declare const ADVISOR_THINKING_LEVELS: readonly ["minimal", "low", "medium", "high", "xhigh"];
+export type AdvisorThinkingLevel = (typeof ADVISOR_THINKING_LEVELS)[number];
+export interface BotConfig {
+    advisor: AdvisorConfig;
+    fastModelId: string;
+    loadingMessages: string[];
+    modelId: string;
+    visionModelId?: string;
+    turnTimeoutMs: number;
+    userName: string;
+}
+export interface AdvisorConfig {
+    modelId: string;
+    thinkingLevel: AdvisorThinkingLevel;
+}
+export interface ChatConfig {
+    bot: BotConfig;
+    functionMaxDurationSeconds: number;
+    slack: {
+        botToken?: string;
+        clientId?: string;
+        clientSecret?: string;
+        signingSecret?: string;
+    };
+    state: {
+        adapter: "memory" | "redis";
+        redisUrl?: string;
+    };
+}
+/** Parse all chat configuration from environment variables. */
+export declare function readChatConfig(env?: NodeJS.ProcessEnv): ChatConfig;
+/** Return the chat configuration (parsed once at startup). */
+export declare function getChatConfig(): ChatConfig;
+/** Bot configuration derived from environment at module load. */
+export declare const botConfig: BotConfig;
+export declare function getSlackBotToken(): string | undefined;
+export declare function getSlackSigningSecret(): string | undefined;
+export declare function getSlackClientId(): string | undefined;
+export declare function getSlackClientSecret(): string | undefined;
+export declare function hasRedisConfig(): boolean;
+export interface RuntimeMetadata {
+    version?: string;
+}
+/** Return runtime metadata (version from deploy environment). */
+export declare function getRuntimeMetadata(): RuntimeMetadata;
+export {};

package/dist/chat/configuration/defaults.d.ts

@@ -0,0 +1,4 @@
+/** Store install-wide config defaults; keys must be registered plugin config keys. */
+export declare function setConfigDefaults(defaults: Record<string, unknown> | undefined): void;
+/** Return the install-wide configuration defaults (empty object when none set). */
+export declare function getConfigDefaults(): Record<string, unknown>;

package/dist/chat/configuration/service.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelConfigurationService, ChannelConfigurationStorage } from "@/chat/configuration/types";
+export declare function createChannelConfigurationService(storage: ChannelConfigurationStorage): ChannelConfigurationService;

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

@@ -0,0 +1,37 @@
+export type ConfigScope = "conversation";
+export interface ConfigEntry {
+    key: string;
+    value: unknown;
+    scope: ConfigScope;
+    updatedAt: string;
+    updatedBy?: string;
+    source?: string;
+    expiresAt?: string;
+}
+export interface ChannelConfigState {
+    schemaVersion: 1;
+    entries: Record<string, ConfigEntry>;
+}
+export interface ChannelConfigurationStorage {
+    load: () => Promise<unknown | null>;
+    save: (state: ChannelConfigState) => Promise<void>;
+}
+export interface ChannelConfigurationService {
+    get: (key: string) => Promise<ConfigEntry | undefined>;
+    set: (input: {
+        key: string;
+        value: unknown;
+        updatedBy?: string;
+        source?: string;
+        expiresAt?: string;
+    }) => Promise<ConfigEntry>;
+    unset: (key: string) => Promise<boolean>;
+    list: (options?: {
+        prefix?: string;
+    }) => Promise<ConfigEntry[]>;
+    resolve: (key: string) => Promise<unknown | undefined>;
+    resolveValues: (options?: {
+        keys?: string[];
+        prefix?: string;
+    }) => Promise<Record<string, unknown>>;
+}

package/dist/chat/configuration/validation.d.ts

@@ -0,0 +1,2 @@
+export declare function validateConfigKey(key: string): string | undefined;
+export declare function validateConfigValue(value: unknown): string | undefined;

package/dist/chat/credentials/broker.d.ts

@@ -0,0 +1,22 @@
+export declare class CredentialUnavailableError extends Error {
+    readonly provider: string;
+    constructor(provider: string, message: string);
+}
+export type CredentialHeaderTransform = {
+    domain: string;
+    headers: Record<string, string>;
+};
+export interface CredentialLease {
+    id: string;
+    provider: string;
+    env: Record<string, string>;
+    headerTransforms?: CredentialHeaderTransform[];
+    expiresAt: string;
+    metadata?: Record<string, string>;
+}
+export interface CredentialBroker {
+    issue(input: {
+        reason: string;
+        requesterId?: string;
+    }): Promise<CredentialLease>;
+}

package/dist/chat/credentials/header-transforms.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialHeaderTransform } from "@/chat/credentials/broker";
+/** Merge transforms by domain so later transforms override earlier headers. */
+export declare function mergeHeaderTransforms(transforms: CredentialHeaderTransform[]): CredentialHeaderTransform[];

package/dist/chat/credentials/oauth-scope.d.ts

@@ -0,0 +1,4 @@
+/** Normalize OAuth scope strings so persisted grants can be compared reliably. */
+export declare function normalizeOAuthScope(scope?: string): string | undefined;
+/** Return whether the stored grant still satisfies the provider's current scope contract. */
+export declare function hasRequiredOAuthScope(storedScope?: string, requiredScope?: string): boolean;

package/dist/chat/credentials/state-adapter-token-store.d.ts

@@ -0,0 +1,9 @@
+import type { StateAdapter } from "chat";
+import type { StoredTokens, UserTokenStore } from "@/chat/credentials/user-token-store";
+export declare class StateAdapterTokenStore implements UserTokenStore {
+    private readonly state;
+    constructor(stateAdapter: StateAdapter);
+    get(userId: string, provider: string): Promise<StoredTokens | undefined>;
+    set(userId: string, provider: string, tokens: StoredTokens): Promise<void>;
+    delete(userId: string, provider: string): Promise<void>;
+}

package/dist/chat/credentials/test-broker.d.ts

@@ -0,0 +1,19 @@
+import type { CredentialBroker, CredentialHeaderTransform, CredentialLease } from "@/chat/credentials/broker";
+interface TestBrokerConfig {
+    provider: string;
+    domains?: string[];
+    apiHeaders?: Record<string, string>;
+    headerTransforms?: () => CredentialHeaderTransform[];
+    env?: Record<string, string>;
+    envKey?: string;
+    placeholder?: string;
+}
+/** Issue deterministic placeholder credential leases for eval runs. */
+export declare class TestCredentialBroker implements CredentialBroker {
+    private readonly config;
+    constructor(config: TestBrokerConfig);
+    issue(input: {
+        reason: string;
+    }): Promise<CredentialLease>;
+}
+export {};

package/dist/chat/credentials/unlink-provider.d.ts

@@ -0,0 +1,2 @@
+import type { UserTokenStore } from "@/chat/credentials/user-token-store";
+export declare function unlinkProvider(userId: string, provider: string, userTokenStore: UserTokenStore): Promise<void>;

package/dist/chat/credentials/user-token-store.d.ts

@@ -0,0 +1,11 @@
+export interface StoredTokens {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt?: number;
+    scope?: string;
+}
+export interface UserTokenStore {
+    get(userId: string, provider: string): Promise<StoredTokens | undefined>;
+    set(userId: string, provider: string, tokens: StoredTokens): Promise<void>;
+    delete(userId: string, provider: string): Promise<void>;
+}

package/dist/chat/discovery.d.ts

@@ -0,0 +1,47 @@
+/** Check whether a path exists and is a directory. */
+export declare function isDirectory(targetPath: string): boolean;
+/** Check whether a path exists and is a regular file. */
+export declare function isFile(targetPath: string): boolean;
+export interface DiscoverNodeModulesDirsOptions {
+    candidateDirs?: string[];
+}
+/** Discover node_modules directories reachable from the current working directory. */
+export declare function discoverNodeModulesDirs(cwd?: string, options?: DiscoverNodeModulesDirsOptions): string[];
+export interface DiscoverProjectRootsOptions {
+    nodeModulesDirs?: string[];
+}
+/** Discover project root directories by walking up from cwd and checking node_modules parents. */
+export declare function discoverProjectRoots(cwd?: string, options?: DiscoverProjectRootsOptions): string[];
+/** Return the resolved app home directory for the current working directory. */
+export declare function homeDir(): string;
+export interface ResolveHomeDirOptions {
+    projectRoots?: string[];
+}
+/** Resolve the app home directory by scoring candidate `app/` directories. */
+export declare function resolveHomeDir(cwd?: string, options?: ResolveHomeDirOptions): string;
+/** Return the data directory (same as homeDir). */
+export declare function dataDir(): string;
+/** Return the path to the SOUL.md file. */
+export declare function soulPath(): string;
+/** Return the path to the WORLD.md file. */
+export declare function worldPath(): string;
+/** Return the path to the DESCRIPTION.md file. */
+export declare function descriptionPath(): string;
+/** Return the skills directory path. */
+export declare function skillsDir(): string;
+/** Return the plugins directory path. */
+export declare function pluginsDir(): string;
+/** Return all unique data root directories. */
+export declare function dataRoots(): string[];
+/** Return all unique skill root directories. */
+export declare function skillRoots(): string[];
+/** Return all unique plugin root directories. */
+export declare function pluginRoots(): string[];
+/** Return candidate paths where SOUL.md might be found. */
+export declare function soulPathCandidates(): string[];
+/** Return candidate paths where WORLD.md might be found. */
+export declare function worldPathCandidates(): string[];
+/** Return candidate paths where DESCRIPTION.md might be found. */
+export declare function descriptionPathCandidates(): string[];
+/** List non-reserved .md files in the app root for sandbox reference syncing. */
+export declare function listReferenceFiles(): string[];

package/dist/chat/ingress/junior-chat.d.ts

@@ -0,0 +1,26 @@
+import { Chat, type ActionEvent, type Adapter, type AppHomeOpenedEvent, type AssistantContextChangedEvent, type AssistantThreadStartedEvent, type Message, type ModalCloseEvent, type ReactionEvent, type SlashCommandEvent, type WebhookOptions } from "chat";
+export declare class JuniorChat<TAdapters extends Record<string, Adapter> = Record<string, Adapter>> extends Chat<TAdapters> {
+    /**
+     * Normalize Slack thread IDs before the SDK's concurrency queue.
+     *
+     * Slack DM roots can arrive with an empty thread timestamp, while
+     * later replies include the root timestamp. Resolve factories before
+     * delegating so the lock/state/subscription key is canonicalized before
+     * the SDK computes its per-thread queue key.
+     */
+    processMessage(adapter: Adapter, threadId: string, messageOrFactory: Message | (() => Promise<Message>), options?: WebhookOptions): Promise<void>;
+    processReaction(event: Omit<ReactionEvent, "adapter" | "thread"> & {
+        adapter?: Adapter;
+    }, options?: WebhookOptions): void;
+    processAction(event: Omit<ActionEvent, "thread" | "openModal"> & {
+        adapter: Adapter;
+    }, options: WebhookOptions | undefined): Promise<void>;
+    processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void;
+    processSlashCommand(event: Omit<SlashCommandEvent, "channel" | "openModal"> & {
+        adapter: Adapter;
+        channelId: string;
+    }, options: WebhookOptions | undefined): void;
+    processAssistantThreadStarted(event: AssistantThreadStartedEvent, options?: WebhookOptions): void;
+    processAssistantContextChanged(event: AssistantContextChangedEvent, options?: WebhookOptions): void;
+    processAppHomeOpened(event: AppHomeOpenedEvent, options?: WebhookOptions): void;
+}

package/dist/chat/ingress/message-changed.d.ts

@@ -0,0 +1,50 @@
+import { Message, type Adapter } from "chat";
+/**
+ * Parsed result from a Slack `message_changed` event that contains a newly
+ * added bot @mention. Returns `null` when the event does not qualify.
+ */
+export interface MessageChangedMention {
+    /** Slack thread ID in `slack:<channel>:<thread_ts>` format. */
+    threadId: string;
+    /** Synthesized Message to pass to `bot.processMessage`. */
+    message: Message;
+}
+interface SlackMessageChangedEvent {
+    type: "event_callback";
+    team_id?: string;
+    event: {
+        type: "message";
+        subtype: "message_changed";
+        channel: string;
+        message: {
+            files?: SlackEditedMessageFile[];
+            source_team?: string;
+            text?: string;
+            ts: string;
+            thread_ts?: string;
+            user?: string;
+            user_team?: string;
+        };
+        previous_message: {
+            text?: string;
+        };
+    };
+}
+interface SlackEditedMessageFile {
+    mimetype?: string;
+    name?: string;
+    original_h?: number;
+    original_w?: number;
+    size?: number;
+    url_private?: string;
+    url_private_download?: string;
+}
+export declare function isMessageChangedEnvelope(value: unknown): value is SlackMessageChangedEvent;
+/**
+ * Inspect a raw parsed Slack webhook body and extract a synthesized mention
+ * event when a `message_changed` edit newly adds the bot's @mention.
+ *
+ * Returns `null` when the payload is not a qualifying `message_changed` event.
+ */
+export declare function extractMessageChangedMention(body: unknown, botUserId: string, adapter: Adapter): MessageChangedMention | null;
+export {};

package/dist/chat/ingress/message-router.d.ts

@@ -0,0 +1,9 @@
+import type { ThreadMessageKind } from "@/chat/queue/thread-message-dispatcher";
+/** Derive canonical Slack thread IDs from the raw event payload. */
+export declare function normalizeIncomingSlackThreadId(threadId: string, message: unknown): string;
+/** Classify an incoming message as a mention or subscribed message. */
+export declare function determineThreadMessageKind(args: {
+    isDirectMessage: boolean;
+    isMention: boolean;
+    isSubscribed: boolean;
+}): ThreadMessageKind | undefined;

package/dist/chat/ingress/slash-command.d.ts

@@ -0,0 +1,3 @@
+import type { SlashCommandEvent } from "chat";
+/** Route `/jr link` and `/jr unlink` slash commands to the appropriate OAuth flow. */
+export declare function handleSlashCommand(event: SlashCommandEvent): Promise<void>;

package/dist/chat/ingress/workspace-membership.d.ts

@@ -0,0 +1,10 @@
+/** Run a callback with the workspace team ID available for membership checks. */
+export declare function runWithWorkspaceTeamId<T>(teamId: string | undefined, fn: () => T): T;
+/**
+ * Return true when a Slack event's author is from an external workspace.
+ *
+ * In Slack Connect shared channels the inner event carries `user_team`
+ * (the author's home workspace). When it differs from the outer payload's
+ * `team_id` the author is a Slack Connect participant, not a local member.
+ */
+export declare function isExternalSlackUser(raw: Record<string, unknown> | undefined): boolean;

package/dist/chat/interruption-marker.d.ts

@@ -0,0 +1,2 @@
+/** Return the marker added when a visible reply ended mid-execution. */
+export declare function getInterruptionMarker(): string;

package/dist/chat/logging.d.ts

@@ -0,0 +1,88 @@
+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;
+    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>;