@sentry/junior 0.183.0 → 0.184.0

package/dist/{agent-hooks-SNRBZYAU.js → agent-hooks-XTZVALGQ.js}

@@ -13,24 +13,24 @@ import {
   getPlugins,
   setPlugins,
   validatePlugins
-} from "./chunk-AHMWPFIW.js";
+} from "./chunk-4CNDGK25.js";
 import "./chunk-3Y47VMHV.js";
-import "./chunk-AX3UDIMA.js";
-import "./chunk-6UXDTPEN.js";
-import "./chunk-X52ESOBP.js";
-import "./chunk-G2B2XZQW.js";
+import "./chunk-IZDYYYGP.js";
+import "./chunk-BCHYQS4B.js";
+import "./chunk-SHJK75Z2.js";
+import "./chunk-DUKIDPF6.js";
 import "./chunk-VFUK3X5B.js";
-import "./chunk-LMNMMESF.js";
-import "./chunk-2ADFGSUS.js";
-import "./chunk-E3OBGRHN.js";
-import "./chunk-EENQGEIP.js";
+import "./chunk-6UDPINOX.js";
+import "./chunk-BHYRYYLY.js";
+import "./chunk-PJPRXO2T.js";
+import "./chunk-LHXIZLFF.js";
 import "./chunk-CEMMLV5L.js";
 import "./chunk-N7TMSOZH.js";
 import "./chunk-DWPN6SCH.js";
 import "./chunk-TXKUKMVO.js";
-import "./chunk-LZBPGX5A.js";
+import "./chunk-3S7ULUWW.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-W46NIB5H.js";
+import "./chunk-6VOYP4M6.js";
 export {
   PluginHookDeniedError,
   applyPluginFormatMarkdown,

package/dist/api/acp/auth.d.ts

@@ -0,0 +1,46 @@
+import * as acp from "@agentclientprotocol/sdk";
+import { type User } from "@sentry/junior-plugin-api";
+import { type AcpState } from "./state";
+import { type AcpRequestReceipt } from "./transport";
+export type AcpAuthorizationCompletion = "busy" | "completed" | "conflict" | "expired" | "invalid";
+export declare const ACP_AUTH_METHOD_ID = "junior";
+export declare const ACP_AUTH_METHOD: {
+    id: string;
+    name: string;
+    description: string;
+};
+/** Create the secret cookie that proves control of one ACP connection. */
+export declare function createAcpConnectionCredential(request: Request): {
+    cookie: string;
+    credentialHash: string;
+};
+/** Verify that this request controls the supplied ACP connection hash. */
+export declare function hasAcpConnectionCredential(request: Request, expectedHash: string): boolean;
+/** Start browser authorization for one ACP authenticate request. */
+export declare function beginAcpAuthorization(args: {
+    baseURL?: string;
+    connectionId: string;
+    credentialHash: string;
+    request: Request;
+    requestId: acp.JsonRpcId;
+    requestKey: string;
+    state: AcpState;
+}): Promise<AcpRequestReceipt>;
+/** Bind a Google-authenticated user and resume the pending ACP request. */
+export declare function completeAcpAuthorization(args: {
+    state: AcpState;
+    transactionId: string;
+    user: User;
+    userCode: string;
+}): Promise<AcpAuthorizationCompletion>;
+/** Consume a client response to the browser URL elicitation. */
+export declare function handleAcpAuthorizationResponse(args: {
+    connectionId: string;
+    response: acp.AnyResponse;
+    state: AcpState;
+}): Promise<"accepted" | "cancelled" | "ignored">;
+/** Finish an abandoned browser authorization while its connection stream is live. */
+export declare function expireAcpAuthorization(args: {
+    connectionId: string;
+    state: AcpState;
+}): Promise<boolean>;

package/dist/api/acp/authorization-page.d.ts

@@ -0,0 +1,11 @@
+/** Own the dashboard-authenticated ACP confirmation page. */
+import type { User } from "@sentry/junior-plugin-api";
+import type { AcpState } from "./state";
+export declare const ACP_AUTHORIZATION_PATH = "/_junior/acp/auth/:transactionId";
+/** Complete one ACP browser authorization for a host-authenticated user. */
+export declare function handleAcpAuthorizationPage(args: {
+    agentName: string;
+    request: Request;
+    state: AcpState;
+    user: User;
+}): Promise<Response>;

package/dist/api/acp/conversations.d.ts

@@ -0,0 +1,70 @@
+/** Bind ACP sessions to Junior's existing Conversation runtime. */
+import type { StateAdapter } from "chat";
+import type { User } from "@sentry/junior-plugin-api";
+import type { ConversationEventStore } from "@/chat/conversations/history";
+import type { ConversationStore } from "@/chat/conversations/store";
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+type ConversationMessage = {
+    id: string;
+    role: "assistant" | "user";
+    text: string;
+};
+type PromptAdmission = {
+    afterCursor: number;
+    messageId: string;
+    status: "accepted";
+    turnId: string;
+} | {
+    status: "active";
+} | {
+    status: "not_found";
+};
+type TurnTerminal = {
+    outcome: "cancelled" | "completed";
+    status: "completed";
+} | {
+    failureCode: string;
+    status: "failed";
+};
+type TurnPage = {
+    cursor: number;
+    messages: ConversationMessage[];
+    terminal?: TurnTerminal;
+};
+/** ACP operations backed by Junior Conversations. */
+export type AcpConversations = {
+    cancel(args: {
+        conversationId: string;
+        user: User;
+    }): Promise<"cancelled" | "not_found">;
+    create(args: {
+        conversationId: string;
+        user: User;
+    }): Promise<void>;
+    hasAccess(args: {
+        conversationId: string;
+        user: User;
+    }): Promise<boolean>;
+    prompt(args: {
+        conversationId: string;
+        idempotencyKey: string;
+        text: string;
+        user: User;
+    }): Promise<PromptAdmission>;
+    readMessages(conversationId: string): Promise<ConversationMessage[]>;
+    readTurn(args: {
+        afterCursor: number;
+        conversationId: string;
+        messageId: string;
+        turnId: string;
+    }): Promise<TurnPage>;
+};
+interface ConversationOptions {
+    conversationStore?: ConversationStore;
+    eventStore: ConversationEventStore;
+    queue: ConversationWorkQueue;
+    state: StateAdapter;
+}
+/** Create the ACP view of Junior's Conversation runtime. */
+export declare function createAcpConversations(options: ConversationOptions): AcpConversations;
+export {};

package/dist/api/acp/errors.d.ts

@@ -0,0 +1,6 @@
+export type AcpErrorContext = {
+    connectionId?: string;
+    conversationId?: string;
+    userId?: string;
+};
+export type ReportAcpError = (error: unknown, event: string, context: AcpErrorContext) => void;

package/dist/api/acp/route.d.ts

@@ -0,0 +1,16 @@
+import type { ReportAcpError } from "./errors";
+import type { AcpConversations } from "./conversations";
+import type { AcpState } from "./state";
+/** Dependencies for the serverless-safe remote ACP HTTP handler. */
+type AcpHttpHandlerOptions = {
+    browserAuth?: {
+        baseURL?: string;
+    };
+    conversations: AcpConversations;
+    onError?: ReportAcpError;
+    state: AcpState;
+    version: string;
+};
+/** Create a serverless-safe remote ACP v1 HTTP handler. */
+export declare function createAcpHttpHandler(options: AcpHttpHandlerOptions): (request: Request) => Promise<Response>;
+export {};

package/dist/api/acp/schema.d.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+export declare const SESSION_HEADER_METHODS: Set<string>;
+export declare const acpConnectionIdSchema: z.ZodString;
+export declare const acpSessionIdSchema: z.ZodString;
+export declare const acpCallSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const acpResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        data: z.ZodOptional<z.ZodUnknown>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+}, z.core.$strict>]>;
+export declare const acpInboundMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        data: z.ZodOptional<z.ZodUnknown>;
+        message: z.ZodString;
+    }, z.core.$strict>;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+}, z.core.$strict>]>]>;
+export declare const initializeParamsSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    clientCapabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    clientInfo: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        name: z.ZodString;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        version: z.ZodString;
+    }, z.core.$strict>>>;
+    protocolVersion: z.ZodNumber;
+}, z.core.$strict>;
+export declare const authenticateParamsSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    methodId: z.ZodString;
+}, z.core.$strict>;
+export declare const newSessionParamsSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    additionalDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodString;
+    mcpServers: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const loadSessionParamsSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    additionalDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodString;
+    mcpServers: z.ZodArray<z.ZodUnknown>;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export declare const promptParamsSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    prompt: z.ZodArray<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        annotations: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            audience: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+            }>>>>;
+            lastModified: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            priority: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>>>;
+        text: z.ZodString;
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strict>>;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export declare const cancelParamsSchema: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export type AcpCall = z.output<typeof acpCallSchema>;
+export type AcpResponse = z.output<typeof acpResponseSchema>;
+export type SessionParams = z.output<typeof newSessionParamsSchema>;
+export type LoadSessionParams = z.output<typeof loadSessionParamsSchema>;
+export type PromptParams = z.output<typeof promptParamsSchema>;
+export type CancelParams = z.output<typeof cancelParamsSchema>;

package/dist/api/acp/sleep.d.ts

@@ -0,0 +1,2 @@
+/** Wait for a duration and reject when the ACP request stops. */
+export declare function sleep(ms: number, signal: AbortSignal): Promise<void>;

package/dist/api/acp/state.d.ts

@@ -0,0 +1,22 @@
+import type { Lock, StateAdapter } from "chat";
+/** One lock held in shared ACP state. */
+export type AcpLock = Lock;
+/** Shared state operations required by the ACP transport. */
+export type AcpState = Pick<StateAdapter, "acquireLock" | "appendToList" | "delete" | "extendLock" | "get" | "getList" | "releaseLock" | "set">;
+export declare const MUTATION_LOCK_TTL_MS = 10000;
+type LockAttempt<T> = {
+    acquired: false;
+} | {
+    acquired: true;
+    value: T;
+};
+/** Run one ACP state mutation while its shared lock remains owned. */
+export declare function withLock<T>(state: AcpState, key: string, run: (lock: AcpLock) => Promise<T>, options?: {
+    keepAlive?: boolean;
+    retryMs?: number;
+    ttlMs?: number;
+    waitMs?: number;
+}): Promise<LockAttempt<T>>;
+/** Prove ACP lock ownership immediately before a blind state write. */
+export declare function fenceLock(state: AcpState, lock: AcpLock, ttlMs?: number): Promise<void>;
+export {};

package/dist/api/acp/transport.d.ts

@@ -0,0 +1,113 @@
+import { type User } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+import type { ReportAcpError } from "./errors";
+import type { AcpConversations } from "./conversations";
+import { type AcpState } from "./state";
+export declare const ACP_STATE_TTL_MS: number;
+declare const acpConnectionSchema: z.ZodObject<{
+    credentialHash: z.ZodString;
+    nonce: z.ZodString;
+    user: z.ZodOptional<z.ZodObject<{
+        displayName: z.ZodOptional<z.ZodString>;
+        email: z.ZodString;
+        id: z.ZodString;
+        identities: z.ZodArray<z.ZodObject<{
+            displayName: z.ZodOptional<z.ZodString>;
+            handle: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            provider: z.ZodString;
+            providerSubjectId: z.ZodString;
+            providerTenantId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const acpStreamRouteSchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const acpPromptStreamOutputSchema: z.ZodObject<{
+    afterSeq: z.ZodNumber;
+    kind: z.ZodLiteral<"prompt">;
+    messageId: z.ZodString;
+    requestId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+    turnId: z.ZodString;
+}, z.core.$strict>;
+declare const acpRequestReceiptSchema: z.ZodObject<{
+    deliveryKey: z.ZodOptional<z.ZodString>;
+    outputs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        message: z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+            jsonrpc: z.ZodLiteral<"2.0">;
+            method: z.ZodString;
+            params: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+            jsonrpc: z.ZodLiteral<"2.0">;
+            result: z.ZodUnknown;
+        }, z.core.$strict>, z.ZodObject<{
+            error: z.ZodObject<{
+                code: z.ZodNumber;
+                data: z.ZodOptional<z.ZodUnknown>;
+                message: z.ZodString;
+            }, z.core.$strict>;
+            id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+            jsonrpc: z.ZodLiteral<"2.0">;
+        }, z.core.$strict>]>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"replay">;
+    }, z.core.$strict>, z.ZodObject<{
+        afterSeq: z.ZodNumber;
+        kind: z.ZodLiteral<"prompt">;
+        messageId: z.ZodString;
+        requestId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+        turnId: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AcpConnection = z.output<typeof acpConnectionSchema>;
+export type AcpStreamRoute = z.output<typeof acpStreamRouteSchema>;
+export type AcpPromptStreamOutput = z.output<typeof acpPromptStreamOutputSchema>;
+export type AcpRequestReceipt = z.output<typeof acpRequestReceiptSchema>;
+/** Create one unauthenticated ACP transport connection. */
+export declare function createAcpConnection(state: AcpState, credentialHash: string): Promise<{
+    connection: AcpConnection;
+    connectionId: string;
+}>;
+/** Read one live ACP transport connection. */
+export declare function readAcpConnection(state: AcpState, connectionId: string): Promise<AcpConnection | undefined>;
+/** Remove one ACP connection so all of its live streams terminate. */
+export declare function deleteAcpConnection(state: AcpState, connectionId: string): Promise<void>;
+/** Bind one live ACP connection to the canonical authorized user. */
+export declare function bindAcpConnectionUser(args: {
+    connectionId: string;
+    credentialHash: string;
+    state: AcpState;
+    user: User;
+}): Promise<"completed" | "conflict" | "expired">;
+/** Replace one pending request receipt and queue its final output once. */
+export declare function completeAcpRequest(args: {
+    connectionId: string;
+    receipt: AcpRequestReceipt;
+    requestKey: string;
+    state: AcpState;
+}): Promise<"completed" | "expired" | "full">;
+/** Store a receipt once and reserve output before side-effecting creation. */
+export declare function acceptAcpRequest(args: {
+    connectionId: string;
+    createReceipt: () => Promise<AcpRequestReceipt>;
+    reserveRoute?: AcpStreamRoute;
+    requestKey: string;
+    state: AcpState;
+}): Promise<"accepted" | "busy" | "expired" | "full">;
+/** Open one connection or session SSE reader backed by shared state. */
+export declare function openAcpSse(args: {
+    conversations: AcpConversations;
+    maintain?: () => Promise<void>;
+    onError?: ReportAcpError;
+    requestSignal: AbortSignal;
+    route: AcpStreamRoute;
+    state: AcpState;
+    userId?: string;
+}): Promise<Response>;
+export {};

package/dist/api.js

@@ -60,12 +60,12 @@ import {
   resolveSlackConversationContextFromThreadId,
   viewerConversationMembership,
   webActorFromEmail
-} from "./chunk-AYW7J6K4.js";
+} from "./chunk-UBOIHNTH.js";
 import {
   buildSentryConversationUrl,
   getWebAuthorization
-} from "./chunk-4WGFWHWP.js";
-import "./chunk-WOKJRLM2.js";
+} from "./chunk-LCP4EDKR.js";
+import "./chunk-M5YWNMTE.js";
 import {
   readTaskExecutionByConversationId,
   readTaskExecutionDays,
@@ -73,9 +73,9 @@ import {
   readTaskExecutionSummaries,
   readTaskExecutions,
   readTaskRuns
-} from "./chunk-W5JMPEBO.js";
+} from "./chunk-6WGC3SO4.js";
 import "./chunk-M3QYTBQ6.js";
-import "./chunk-PLZT45VC.js";
+import "./chunk-E57WPXWY.js";
 import {
   healthReportSchema,
   pluginOperationalReportFeedSchema,
@@ -83,7 +83,7 @@ import {
   runtimeInfoReportSchema,
   skillReportsSchema
 } from "./chunk-UTL3MHPC.js";
-import "./chunk-V64JCZUV.js";
+import "./chunk-UF6BUA5W.js";
 import {
   deleteEventTask,
   eventTaskBelongsToUser,
@@ -100,31 +100,31 @@ import {
   readScheduledTask,
   readStats,
   saveScheduledTask
-} from "./chunk-R767Y7QV.js";
+} from "./chunk-HIPUIPJM.js";
 import {
   parseSlackThreadId
-} from "./chunk-SQHFVIMZ.js";
+} from "./chunk-YKX6MTLU.js";
 import {
   cancelHumanFacingPendingMessages,
   getConversation
-} from "./chunk-HUK5XIZL.js";
-import "./chunk-56XONJPF.js";
+} from "./chunk-Z3QAXJR7.js";
+import "./chunk-JA43DV4Y.js";
 import {
   agentTurnUsageSchema,
   fallbackShortTitle,
   hasAgentTurnUsage,
   renderJuniorNativeConversationEvent
-} from "./chunk-24OJZ5OU.js";
+} from "./chunk-2ZQPVX7C.js";
 import {
   getCachedSnapshot
-} from "./chunk-37IQ6DGU.js";
+} from "./chunk-MAPJFUMV.js";
 import "./chunk-PDO5BLNM.js";
 import {
   getVercelConversationWorkQueue
 } from "./chunk-DKIJ2RP5.js";
 import "./chunk-JAL3CH4G.js";
 import "./chunk-7H2VZTWN.js";
-import "./chunk-FJMTMGBC.js";
+import "./chunk-MLSQX2EX.js";
 import {
   SANDBOX_RUNTIME,
   WorkspaceValidationError,
@@ -144,7 +144,7 @@ import {
   updateWorkspace,
   withSlackRetries,
   workspaceRepoCheckoutPath
-} from "./chunk-AHMWPFIW.js";
+} from "./chunk-4CNDGK25.js";
 import "./chunk-3Y47VMHV.js";
 import {
   decodeStoredConversationEvent,
@@ -154,7 +154,7 @@ import {
   locationFromRow,
   parseSessionSource,
   resolveRootConversationId
-} from "./chunk-AX3UDIMA.js";
+} from "./chunk-IZDYYYGP.js";
 import {
   conversationReadColumns,
   juniorApiTokens,
@@ -166,19 +166,19 @@ import {
   juniorIdentities,
   juniorSchedulerTasks,
   juniorUsers
-} from "./chunk-6UXDTPEN.js";
+} from "./chunk-BCHYQS4B.js";
 import {
   create,
   hash
-} from "./chunk-X52ESOBP.js";
-import "./chunk-G2B2XZQW.js";
+} from "./chunk-SHJK75Z2.js";
+import "./chunk-DUKIDPF6.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-LMNMMESF.js";
-import "./chunk-2ADFGSUS.js";
-import "./chunk-E3OBGRHN.js";
-import "./chunk-EENQGEIP.js";
+import "./chunk-6UDPINOX.js";
+import "./chunk-BHYRYYLY.js";
+import "./chunk-PJPRXO2T.js";
+import "./chunk-LHXIZLFF.js";
 import "./chunk-CEMMLV5L.js";
 import {
   parseSlackChannelId,
@@ -190,9 +190,9 @@ import "./chunk-TXKUKMVO.js";
 import {
   logException,
   logWarn
-} from "./chunk-LZBPGX5A.js";
+} from "./chunk-3S7ULUWW.js";
 import "./chunk-PEQXYSSE.js";
-import "./chunk-W46NIB5H.js";
+import "./chunk-6VOYP4M6.js";
 
 // src/api.ts
 import { Hono as Hono9 } from "hono";
@@ -4314,7 +4314,7 @@ async function readPeoplePluginReports(args) {
       source: "plugins"
     });
   }
-  const { getPluginProfileReports } = await import("./agent-hooks-SNRBZYAU.js");
+  const { getPluginProfileReports } = await import("./agent-hooks-XTZVALGQ.js");
   return pluginOperationalReportFeedSchema.parse({
     generatedAt: new Date(nowMs).toISOString(),
     reports: await getPluginProfileReports({
@@ -5110,7 +5110,7 @@ function readDescriptionText(home) {
   }
 }
 async function readSkillReports() {
-  const { discoverSkills } = await import("./skills-EXIQ7BP5.js");
+  const { discoverSkills } = await import("./skills-X3DY7AXO.js");
   const skills = await discoverSkills();
   return skillReportsSchema.parse(
     skills.map((skill) => ({
@@ -5120,7 +5120,7 @@ async function readSkillReports() {
   );
 }
 async function readPlugins() {
-  const { pluginCatalogRuntime } = await import("./catalog-runtime-3I3JOIIH.js");
+  const { pluginCatalogRuntime } = await import("./catalog-runtime-5357XR4F.js");
   return pluginsSchema.parse(
     pluginCatalogRuntime.getProviders().map((plugin) => ({
       configKeys: plugin.manifest.configKeys ?? [],
@@ -5133,7 +5133,7 @@ async function readPlugins() {
 async function readRuntimeInfoReport() {
   const [{ homeDir }, { pluginCatalogRuntime }, plugins, skills] = await Promise.all([
     import("./discovery-DWVDM7UK.js"),
-    import("./catalog-runtime-3I3JOIIH.js"),
+    import("./catalog-runtime-5357XR4F.js"),
     readPlugins(),
     readSkillReports()
   ]);
@@ -5149,7 +5149,7 @@ async function readRuntimeInfoReport() {
 }
 async function readPluginOperationalReportFeed() {
   const nowMs = Date.now();
-  const { getPluginOperationalReports } = await import("./agent-hooks-SNRBZYAU.js");
+  const { getPluginOperationalReports } = await import("./agent-hooks-XTZVALGQ.js");
   return pluginOperationalReportFeedSchema.parse({
     source: "plugins",
     generatedAt: new Date(nowMs).toISOString(),

package/dist/app.d.ts

@@ -4,15 +4,11 @@ import { type SandboxResourceConfig } from "@/chat/sandbox/resources";
 import { type JuniorPluginSet } from "./plugins";
 import type { ConversationWorkCallbackOptions } from "@/chat/app/conversation-work";
 import type { WaitUntilFn } from "@/handlers/types";
-import type { JuniorAppAdapter } from "./app-adapter";
 import { JUNIOR_VERSION } from "./version";
 export { defineJuniorPlugins } from "./plugins";
 export { JUNIOR_VERSION };
 export type { JuniorPluginInput, JuniorPluginSet, JuniorPluginSetOptions, } from "./plugins";
-export type { AdapterConversations, AdapterMessage, AdapterPromptAdmission, AdapterTurnPage, AdapterTurnTerminal, JuniorAdapterState, JuniorAppAdapter, JuniorAppAdapterContext, JuniorAppAdapterRoutes, JuniorAuthenticatedRoute, } from "./app-adapter";
 export interface JuniorAppOptions {
-    /** Non-plugin adapters mounted against Junior's shared runtime. */
-    adapters?: readonly JuniorAppAdapter[];
     /** Authenticated dashboard mounted by core when configured. */
     dashboard?: JuniorDashboardOptions;
     /**