@sentry/junior 0.57.0 → 0.59.0

package/dist/chat/state/artifacts.d.ts

@@ -12,6 +12,7 @@ export interface CanvasArtifactSummary {
 }
 export interface ThreadArtifactsState {
     assistantContextChannelId?: string;
+    assistantTitle?: string;
     assistantTitleSourceMessageId?: string;
     lastCanvasId?: string;
     lastCanvasUrl?: string;

package/dist/chat/state/conversation.d.ts

@@ -38,7 +38,6 @@ export interface ConversationBackfillState {
 export interface ConversationProcessingState {
     activeTurnId?: string;
     lastCompletedAtMs?: number;
-    lastSessionId?: string;
     pendingAuth?: ConversationPendingAuthState;
 }
 export interface ConversationPendingAuthState {

package/dist/chat/state/session-log.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import type { PiMessage } from "@/chat/pi/messages";
+declare const authorizationKindSchema: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"pi_message">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    message: z.ZodPipe<z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+        [x: string]: unknown;
+        role: string;
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"projection_reset">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    messages: z.ZodArray<z.ZodPipe<z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+        [x: string]: unknown;
+        role: string;
+    }>>>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"mcp_provider_connected">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    provider: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"authorization_requested">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    createdAtMs: z.ZodNumber;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+    provider: z.ZodString;
+    requesterId: z.ZodString;
+    authorizationId: z.ZodString;
+    delivery: z.ZodUnion<readonly [z.ZodLiteral<"private_link_sent">, z.ZodLiteral<"private_link_reused">]>;
+}, z.core.$strip>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    type: z.ZodLiteral<"authorization_completed">;
+    sessionId: z.ZodDefault<z.ZodString>;
+    createdAtMs: z.ZodNumber;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
+    provider: z.ZodString;
+    requesterId: z.ZodString;
+    authorizationId: z.ZodString;
+}, z.core.$strip>], "type">;
+export type SessionLogEntry = z.infer<typeof sessionLogEntrySchema>;
+export type AuthorizationKind = z.infer<typeof authorizationKindSchema>;
+interface Scope {
+    conversationId: string;
+}
+interface AppendArgs {
+    entries: SessionLogEntry[];
+    scope: Scope;
+    ttlMs: number;
+}
+export interface SessionLogStore {
+    append(args: AppendArgs): Promise<void>;
+    read(scope: Scope): Promise<SessionLogEntry[]>;
+}
+/** Load the committed Pi-message projection for a conversation. */
+export declare function loadMessages(args: Scope & {
+    store?: SessionLogStore;
+    messageCount: number;
+    sessionId?: string;
+}): Promise<PiMessage[] | undefined>;
+/** Load the full current Pi-message projection for a conversation. */
+export declare function loadProjection(args: Scope & {
+    store?: SessionLogStore;
+    sessionId?: string;
+}): Promise<PiMessage[]>;
+/** Load MCP providers that were durably connected in this conversation. */
+export declare function loadConnectedMcpProviders(args: Scope & {
+    store?: SessionLogStore;
+}): Promise<string[]>;
+/** Record a successful MCP provider connection without duplicating the fact. */
+export declare function recordMcpProviderConnected(args: Scope & {
+    store?: SessionLogStore;
+    provider: string;
+    ttlMs: number;
+}): Promise<void>;
+/** Record that an OAuth/MCP authorization link was delivered or reused. */
+export declare function recordAuthorizationRequested(args: Scope & {
+    store?: SessionLogStore;
+    kind: AuthorizationKind;
+    provider: string;
+    requesterId: string;
+    authorizationId: string;
+    delivery: "private_link_sent" | "private_link_reused";
+    ttlMs: number;
+}): Promise<void>;
+/** Record completed authorization as a chronological host observation for Pi. */
+export declare function recordAuthorizationCompleted(args: Scope & {
+    store?: SessionLogStore;
+    kind: AuthorizationKind;
+    provider: string;
+    requesterId: string;
+    authorizationId: string;
+    ttlMs: number;
+}): Promise<void>;
+/**
+ * Append conversation-log entries and advance the current Pi projection.
+ *
+ * Normal commits append new Pi messages. If the runtime rolls back to an
+ * earlier safe boundary, the log records that projection reset as an explicit
+ * event instead of rewriting prior history.
+ */
+export declare function commitMessages(args: Scope & {
+    store?: SessionLogStore;
+    messages: PiMessage[];
+    ttlMs: number;
+}): Promise<{
+    sessionId: string;
+}>;
+export {};

package/dist/chat/state/ttl.d.ts

@@ -0,0 +1,2 @@
+/** Retain expiring conversation/runtime state long enough for resume and dashboard history. */
+export declare const JUNIOR_THREAD_STATE_TTL_MS: number;

package/dist/chat/state/turn-session.d.ts

@@ -0,0 +1,89 @@
+import type { PiMessage } from "@/chat/pi/messages";
+import type { AgentTurnUsage } from "@/chat/usage";
+export type AgentTurnSessionStatus = "running" | "awaiting_resume" | "completed" | "failed" | "abandoned";
+export type AgentTurnResumeReason = "timeout" | "auth";
+export interface AgentTurnRequester {
+    email?: string;
+    fullName?: string;
+    slackUserId?: string;
+    slackUserName?: string;
+}
+export interface AgentTurnSessionRecord {
+    channelName?: string;
+    conversationTitle?: string;
+    version: number;
+    conversationId: string;
+    cumulativeDurationMs?: number;
+    cumulativeUsage?: AgentTurnUsage;
+    errorMessage?: string;
+    lastProgressAtMs: number;
+    loadedSkillNames?: string[];
+    piMessages: PiMessage[];
+    requester?: AgentTurnRequester;
+    resumeReason?: AgentTurnResumeReason;
+    resumedFromSliceId?: number;
+    sessionId: string;
+    sliceId: number;
+    startedAtMs: number;
+    state: AgentTurnSessionStatus;
+    traceId?: string;
+    updatedAtMs: number;
+}
+export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages">;
+/** Read a materialized turn session record for resume and history loading. */
+export declare function getAgentTurnSessionRecord(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
+/** Commit stable Pi session state and advance the turn session record. */
+export declare function upsertAgentTurnSessionRecord(args: {
+    channelName?: string;
+    conversationTitle?: string;
+    conversationId: string;
+    cumulativeDurationMs?: number;
+    cumulativeUsage?: AgentTurnUsage;
+    lastProgressAtMs?: number;
+    loadedSkillNames?: string[];
+    sessionId: string;
+    sliceId: number;
+    state: AgentTurnSessionStatus;
+    piMessages: PiMessage[];
+    requester?: AgentTurnRequester;
+    resumeReason?: AgentTurnResumeReason;
+    errorMessage?: string;
+    resumedFromSliceId?: number;
+    traceId?: string;
+    ttlMs?: number;
+}): Promise<AgentTurnSessionRecord>;
+/** Record turn-session metadata without storing conversation messages. */
+export declare function recordAgentTurnSessionSummary(args: {
+    channelName?: string;
+    conversationTitle?: string;
+    conversationId: string;
+    cumulativeDurationMs?: number;
+    cumulativeUsage?: AgentTurnUsage;
+    lastProgressAtMs?: number;
+    loadedSkillNames?: string[];
+    requester?: AgentTurnRequester;
+    resumeReason?: AgentTurnResumeReason;
+    sessionId: string;
+    sliceId: number;
+    startedAtMs?: number;
+    state: AgentTurnSessionStatus;
+    traceId?: string;
+    ttlMs?: number;
+}): Promise<void>;
+/** List recent turn-session summaries for authenticated operational dashboards. */
+export declare function listAgentTurnSessionSummaries(limit?: number): Promise<AgentTurnSessionSummary[]>;
+/** List turn-session summaries for one conversation without the global feed cap. */
+export declare function listAgentTurnSessionSummariesForConversation(conversationId: string): Promise<AgentTurnSessionSummary[]>;
+/** Mark an unfinished turn session record as abandoned when a newer turn wins. */
+export declare function abandonAgentTurnSessionRecord(args: {
+    conversationId: string;
+    sessionId: string;
+    errorMessage?: string;
+}): Promise<AgentTurnSessionRecord | undefined>;
+/** Mark an unfinished turn session record as failed so it cannot resume. */
+export declare function failAgentTurnSessionRecord(args: {
+    conversationId: string;
+    expectedVersion: number;
+    sessionId: string;
+    errorMessage?: string;
+}): Promise<AgentTurnSessionRecord | undefined>;

package/dist/chat/tools/advisor/tool.d.ts

@@ -1,5 +1,6 @@
 import { type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import type { AdvisorConfig } from "@/chat/config";
+import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import { type LogContext } from "@/chat/logging";
 import { type AdvisorSessionStore } from "@/chat/tools/advisor/session-store";
 import { type ToolDefinition } from "@/chat/tools/definition";
@@ -19,6 +20,7 @@ export interface AdvisorToolResult {
 export interface AdvisorToolRuntimeContext {
     config: AdvisorConfig;
     conversationId?: string;
+    conversationPrivacy?: ConversationPrivacy;
     getTools: () => AgentTool[];
     logContext?: LogContext;
     store?: AdvisorSessionStore;

package/dist/chat/tools/agent-tools.d.ts

@@ -1,4 +1,5 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type ConversationPrivacy } from "@/chat/conversation-privacy";
 import { type LogContext } from "@/chat/logging";
 import type { PluginAuthOrchestration } from "@/chat/services/plugin-auth-orchestration";
 import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
@@ -7,4 +8,4 @@ import type { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
 import type { ToolDefinition } from "@/chat/tools/definition";
 import type { AgentPluginHookRunner } from "@/chat/plugins/agent-hooks";
 /** Wrap tool definitions into Pi Agent tool objects with logging, validation, and sandbox execution. */
-export declare function createAgentTools(tools: Record<string, ToolDefinition<any>>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolName: string, params: Record<string, unknown>) => void, agentHooks?: AgentPluginHookRunner): AgentTool[];
+export declare function createAgentTools(tools: Record<string, ToolDefinition<any>>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxExecutor?: SandboxExecutor, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolName: string, params: Record<string, unknown>) => void, agentHooks?: AgentPluginHookRunner, conversationPrivacy?: ConversationPrivacy): AgentTool[];

package/dist/chat/tools/skill/call-mcp-tool.d.ts

@@ -1,7 +1,11 @@
-import type { McpToolManager } from "@/chat/mcp/tool-manager";
-import type { Skill } from "@/chat/skills";
+import type { ManagedMcpTool } from "@/chat/mcp/tool-manager";
+interface CallMcpToolManager {
+    activateProvider(provider: string): Promise<boolean>;
+    getResolvedActiveTools(): ManagedMcpTool[];
+}
 /** Create the stable dispatcher for active MCP provider tools. */
-export declare function createCallMcpToolTool(mcpToolManager: McpToolManager, getActiveSkills: () => Skill[]): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+export declare function createCallMcpToolTool(mcpToolManager: CallMcpToolManager): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     tool_name: import("@sinclair/typebox").TString;
     arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
 }>>;
+export {};

package/dist/chat/tools/skill/search-mcp-tools.d.ts

@@ -1,8 +1,20 @@
-import type { McpToolManager } from "@/chat/mcp/tool-manager";
-import type { Skill } from "@/chat/skills";
+import type { ManagedMcpToolDescriptor } from "@/chat/mcp/tool-manager";
+interface ProviderSummary {
+    provider: string;
+    description: string;
+    active: boolean;
+}
+interface SearchMcpToolManager {
+    activateProvider(provider: string): Promise<boolean>;
+    getActiveToolCatalog(options?: {
+        provider?: string;
+    }): ManagedMcpToolDescriptor[];
+    getAvailableProviderCatalog(): ProviderSummary[];
+}
 /** Create the progressive MCP catalog search tool used before callMcpTool. */
-export declare function createSearchMcpToolsTool(mcpToolManager: McpToolManager, getActiveSkills: () => Skill[]): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
+export declare function createSearchMcpToolsTool(mcpToolManager: SearchMcpToolManager): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
     query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     provider: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     max_results: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
 }>>;
+export {};

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

@@ -48,7 +48,6 @@ export interface ToolRuntimeContext {
     userText?: string;
     artifactState?: ThreadArtifactsState;
     configuration?: Record<string, unknown>;
-    getActiveSkills?: () => Skill[];
     mcpToolManager?: McpToolManager;
     sandbox: SandboxWorkspace;
 }