@sentry/junior 0.72.0 → 0.74.0

package/dist/{chunk-QUXPUKBH.js → chunk-Y7X25LFY.js}

@@ -1,6 +1,6 @@
 // src/vercel.ts
 function juniorVercelConfig(options = {}) {
-  const buildCommand = options.buildCommand === void 0 ? "pnpm build" : options.buildCommand;
+  const buildCommand = options.buildCommand === void 0 ? "pnpm exec junior upgrade && pnpm build" : options.buildCommand;
   const config = {
     framework: "nitro"
   };

package/dist/{chunk-ICKIDP7G.js → chunk-YOHFWWBV.js}

@@ -1,7 +1,7 @@
 import {
   destinationKey,
   parseDestination
-} from "./chunk-XC33FJZN.js";
+} from "./chunk-YRDS7VKO.js";
 
 // src/plugins.ts
 function cloneManifests(manifests) {

package/dist/{chunk-XC33FJZN.js → chunk-YRDS7VKO.js}

@@ -1,11 +1,11 @@
 import {
   getSlackBotToken
-} from "./chunk-ZJQPA67D.js";
+} from "./chunk-GM7HTXYC.js";
 import {
   isSlackConversationId,
   isSlackTeamId,
   logWarn
-} from "./chunk-6GEYPE6T.js";
+} from "./chunk-3BYAPS6B.js";
 
 // src/chat/slack/client.ts
 import { WebClient } from "@slack/web-api";
@@ -277,7 +277,9 @@ async function downloadPrivateSlackFile(url) {
 }
 
 // src/chat/destination.ts
-import { destinationSchema } from "@sentry/junior-plugin-api";
+import {
+  destinationSchema
+} from "@sentry/junior-plugin-api";
 function createSlackDestination(input) {
   const channelId = normalizeSlackConversationId(input.channelId);
   const teamId = input.teamId?.trim();
@@ -293,10 +295,28 @@ function parseDestination(value) {
   const parsed = destinationSchema.safeParse(value);
   return parsed.success ? parsed.data : void 0;
 }
+function requireSlackDestination(destination, action) {
+  if (destination?.platform === "slack") {
+    return destination;
+  }
+  throw new Error(`${action} requires a Slack destination`);
+}
 function sameDestination(left, right) {
-  return left.platform === right.platform && left.teamId === right.teamId && left.channelId === right.channelId;
+  if (left.platform !== right.platform) {
+    return false;
+  }
+  if (left.platform === "local" && right.platform === "local") {
+    return left.conversationId === right.conversationId;
+  }
+  if (left.platform === "slack" && right.platform === "slack") {
+    return left.teamId === right.teamId && left.channelId === right.channelId;
+  }
+  return false;
 }
 function destinationKey(destination) {
+  if (destination.platform === "local") {
+    return destination.conversationId;
+  }
   return `slack:${destination.teamId}:${destination.channelId}`;
 }
 
@@ -313,6 +333,7 @@ export {
   downloadPrivateSlackFile,
   createSlackDestination,
   parseDestination,
+  requireSlackDestination,
   sameDestination,
   destinationKey
 };

package/dist/cli/chat.js

@@ -0,0 +1,205 @@
+import "../chunk-2KG3PWR4.js";
+
+// src/cli/chat.ts
+import {
+  stdin as defaultStdin,
+  stderr as defaultStderr,
+  stdout as defaultStdout
+} from "process";
+import { randomUUID } from "crypto";
+import * as readline from "readline/promises";
+
+// src/chat/local/conversation.ts
+import { createHash } from "crypto";
+import path from "path";
+var LOCAL_CONVERSATION_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function slugifyConversationAlias(alias) {
+  const trimmed = alias.trim();
+  if (!LOCAL_CONVERSATION_ALIAS_PATTERN.test(trimmed)) {
+    return void 0;
+  }
+  return trimmed.toLowerCase().replaceAll(".", "-");
+}
+function workspaceKey(cwd) {
+  return createHash("sha256").update(path.resolve(cwd)).digest("hex").slice(0, 12);
+}
+function normalizeLocalConversationId(input) {
+  const slug = slugifyConversationAlias(input.alias);
+  if (!slug) {
+    return void 0;
+  }
+  return `local:${workspaceKey(input.cwd ?? process.cwd())}:${slug}`;
+}
+
+// src/cli/chat.ts
+var CHAT_USAGE = "usage: junior chat\n       junior chat -p <message>";
+var DEFAULT_IO = {
+  error: (line) => writeStream(defaultStderr, `${line}
+`),
+  input: defaultStdin,
+  output: defaultStdout,
+  write: (text) => writeStream(defaultStdout, text)
+};
+var ChatOutputError = class extends Error {
+  constructor(error) {
+    super(errorMessage(error));
+    this.name = "ChatOutputError";
+  }
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function deliverReply(io, reply) {
+  try {
+    const files = reply.files ?? [];
+    if (files.length > 0) {
+      const names = files.map(
+        (file) => typeof file.filename === "string" && file.filename.trim() ? file.filename : "generated file"
+      ).join(", ");
+      throw new Error(`Local chat cannot deliver files yet: ${names}`);
+    }
+    await io.write(formatReply(reply));
+  } catch (error) {
+    throw new ChatOutputError(error);
+  }
+}
+async function reportStatus(io, status) {
+  try {
+    await io.error(status);
+  } catch (error) {
+    throw new ChatOutputError(error);
+  }
+}
+function writeStream(stream, text) {
+  return new Promise((resolve, reject) => {
+    stream.write(text, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function defaultStateAdapterForLocalChat() {
+  if (process.env.JUNIOR_STATE_ADAPTER) {
+    return;
+  }
+  process.env.JUNIOR_STATE_ADAPTER = "memory";
+}
+function parseChatArgs(argv) {
+  if (argv.length === 0) {
+    return { mode: "interactive" };
+  }
+  if (argv[0] !== "-p") {
+    return void 0;
+  }
+  const message = argv.slice(1).join(" ").trim();
+  if (!message) {
+    return void 0;
+  }
+  return { message, mode: "prompt" };
+}
+function formatReply(reply) {
+  const lines = [];
+  const text = reply.text.trim();
+  if (text) {
+    lines.push(text);
+  }
+  return `${lines.join("\n") || "[empty response]"}
+`;
+}
+function newRunConversationId() {
+  const conversationId = normalizeLocalConversationId({
+    alias: `run-${randomUUID()}`
+  });
+  if (!conversationId) {
+    throw new Error("Invalid local conversation name");
+  }
+  return conversationId;
+}
+async function runPrompt(options, io) {
+  defaultStateAdapterForLocalChat();
+  const conversationId = newRunConversationId();
+  const { runLocalAgentTurn } = await import("../runner-27NP2TEO.js");
+  const result = await runLocalAgentTurn(
+    {
+      conversationId,
+      message: options.message
+    },
+    {
+      deliverReply: async (reply) => {
+        await deliverReply(io, reply);
+      },
+      onStatus: async (status) => {
+        await reportStatus(io, status);
+      }
+    }
+  );
+  return result.outcome === "success" ? 0 : 1;
+}
+async function runInteractive(io) {
+  defaultStateAdapterForLocalChat();
+  const conversationId = newRunConversationId();
+  const { runLocalAgentTurn } = await import("../runner-27NP2TEO.js");
+  const rl = readline.createInterface({
+    input: io.input,
+    output: io.output,
+    terminal: true
+  });
+  try {
+    while (true) {
+      const message = (await rl.question("junior> ")).trim();
+      if (!message) {
+        continue;
+      }
+      if (message === "/exit" || message === "/quit") {
+        break;
+      }
+      try {
+        await runLocalAgentTurn(
+          {
+            conversationId,
+            message
+          },
+          {
+            deliverReply: async (reply) => {
+              await deliverReply(io, reply);
+            },
+            onStatus: async (status) => {
+              await reportStatus(io, status);
+            }
+          }
+        );
+      } catch (error) {
+        if (error instanceof ChatOutputError) {
+          throw error;
+        }
+        await reportStatus(io, errorMessage(error));
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function runChat(argv, io = DEFAULT_IO) {
+  const options = parseChatArgs(argv);
+  if (!options) {
+    await io.error(CHAT_USAGE);
+    return 1;
+  }
+  try {
+    if (options.mode === "prompt") {
+      return await runPrompt(options, io);
+    }
+    await runInteractive(io);
+    return 0;
+  } catch (error) {
+    await io.error(errorMessage(error));
+    return 1;
+  }
+}
+export {
+  CHAT_USAGE,
+  runChat
+};

package/dist/cli/check.js

@@ -1,19 +1,18 @@
-import {
-  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
-  JUNIOR_HEARTBEAT_ROUTE,
-  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
-} from "../chunk-6YY4Q3D4.js";
 import {
   parseSkillFile
-} from "../chunk-55XEZFGD.js";
+} from "../chunk-OR6NQJ5E.js";
 import {
   parseInlinePluginManifest,
   parsePluginManifest
-} from "../chunk-GB3AL54K.js";
+} from "../chunk-7Q5YOUUT.js";
 import "../chunk-KVZL5NZS.js";
-import "../chunk-PP7AGSBU.js";
-import "../chunk-6GEYPE6T.js";
-import "../chunk-Z3YD6NHK.js";
+import "../chunk-CYUI7JU5.js";
+import "../chunk-3BYAPS6B.js";
+import {
+  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
+  JUNIOR_HEARTBEAT_ROUTE,
+  LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
+} from "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/check.ts

package/dist/cli/init.js

@@ -1,6 +1,6 @@
 import {
   juniorVercelConfig
-} from "../chunk-QUXPUKBH.js";
+} from "../chunk-Y7X25LFY.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/init.ts

package/dist/cli/run.js

@@ -1,12 +1,20 @@
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/run.ts
-var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade";
+var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade\n       junior chat\n       junior chat -p <message>";
 var DEFAULT_IO = {
   error: console.error
 };
+function normalizeCliArgv(argv) {
+  return argv[0] === "--" ? argv.slice(1) : argv;
+}
 async function runCli(argv, handlers, io = DEFAULT_IO) {
-  const [command, subcommand, ...rest] = argv;
+  const [command, subcommand, ...rest] = normalizeCliArgv(argv);
+  if (command === "chat") {
+    return await handlers.runChat(
+      subcommand === void 0 ? [] : [subcommand, ...rest]
+    );
+  }
   if (command === "init") {
     if (!subcommand || rest.length > 0) {
       io.error(CLI_USAGE);

package/dist/cli/snapshot-warmup.js

@@ -1,20 +1,20 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-VLIO6RQR.js";
+} from "../chunk-6UP2Z2RZ.js";
 import "../chunk-G3E7SCME.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-GB3AL54K.js";
+} from "../chunk-7Q5YOUUT.js";
 import "../chunk-KVZL5NZS.js";
 import {
   disconnectStateAdapter
-} from "../chunk-3FYPXHPL.js";
-import "../chunk-ZJQPA67D.js";
-import "../chunk-PP7AGSBU.js";
-import "../chunk-6GEYPE6T.js";
-import "../chunk-Z3YD6NHK.js";
+} from "../chunk-F6HWCPOC.js";
+import "../chunk-GM7HTXYC.js";
+import "../chunk-CYUI7JU5.js";
+import "../chunk-3BYAPS6B.js";
+import "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/snapshot-warmup.ts

package/dist/cli/upgrade.js

@@ -1,31 +1,93 @@
 import {
   coerceThreadConversationState
-} from "../chunk-4JXCSGSA.js";
+} from "../chunk-M4FLLXXD.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
+  createNeonJuniorSqlExecutor,
+  createSqlStore,
+  createStateConversationStore,
   getConversation,
   requestConversationWork
-} from "../chunk-HNMUVGSR.js";
+} from "../chunk-JL2SLRAT.js";
 import {
   parseDestination,
   sameDestination
-} from "../chunk-XC33FJZN.js";
+} from "../chunk-YRDS7VKO.js";
 import {
   disconnectStateAdapter,
   getConnectedStateContext
-} from "../chunk-3FYPXHPL.js";
+} from "../chunk-F6HWCPOC.js";
 import {
   getChatConfig
-} from "../chunk-ZJQPA67D.js";
-import "../chunk-PP7AGSBU.js";
+} from "../chunk-GM7HTXYC.js";
+import "../chunk-CYUI7JU5.js";
 import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "../chunk-6GEYPE6T.js";
-import "../chunk-Z3YD6NHK.js";
+} from "../chunk-3BYAPS6B.js";
+import "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
+// src/chat/conversations/sql/backfill.ts
+async function backfillToSql(args) {
+  const limit = Math.max(0, args.limit ?? 500);
+  const conversations = await args.source.listByActivity({
+    limit
+  });
+  await args.target.migrate();
+  for (const conversation of conversations) {
+    await args.target.backfillConversation(conversation);
+  }
+  return {
+    copiedCount: conversations.length
+  };
+}
+
+// src/cli/upgrade/migrations/conversations-sql.ts
+var CONVERSATION_BACKFILL_LIMIT = 1e4;
+var REQUIRED_SQL_DATABASE_URL_MESSAGE = "Junior SQL database URL is required for conversation metadata upgrade. Set JUNIOR_DATABASE_URL or DATABASE_URL.";
+function requireConversationSqlDatabaseUrl(context) {
+  const databaseUrl = context.sqlDatabaseUrl ?? getChatConfig().sql.databaseUrl;
+  if (!databaseUrl) {
+    throw new Error(REQUIRED_SQL_DATABASE_URL_MESSAGE);
+  }
+  return databaseUrl;
+}
+async function migrateConversationsToSql(context, options = {}) {
+  const source = createStateConversationStore(context.stateAdapter);
+  let target = options.target;
+  let closeTarget;
+  if (!target) {
+    const databaseUrl = requireConversationSqlDatabaseUrl(context);
+    const executor = createNeonJuniorSqlExecutor({
+      connectionString: databaseUrl
+    });
+    target = createSqlStore(executor);
+    closeTarget = () => executor.close();
+  }
+  const limit = Math.max(1, options.batchSize ?? CONVERSATION_BACKFILL_LIMIT);
+  try {
+    const result = await backfillToSql({
+      limit,
+      source,
+      target
+    });
+    return {
+      existing: 0,
+      migrated: result.copiedCount,
+      missing: 0,
+      scanned: result.copiedCount
+    };
+  } finally {
+    await closeTarget?.();
+  }
+}
+var sqlConversationMigration = {
+  name: "backfill-conversations-sql",
+  run: migrateConversationsToSql
+};
+
 // src/cli/upgrade/migrations/redis-conversation-state.ts
 var CONVERSATION_PREFIX = "junior:conversation";
 var CONVERSATION_SCHEMA_VERSION = 1;
@@ -562,16 +624,24 @@ var redisConversationStateMigration = {
 var DEFAULT_IO = {
   info: console.log
 };
-var MIGRATIONS = [redisConversationStateMigration];
+var MIGRATIONS = [
+  redisConversationStateMigration,
+  sqlConversationMigration
+];
 function formatMigrationResult(result) {
-  return [
+  const fields = [
     `scanned=${result.scanned}`,
     `migrated=${result.migrated}`,
     `existing=${result.existing}`,
     `missing=${result.missing}`
-  ].join(" ");
+  ];
+  if (result.skipped !== void 0) {
+    fields.push(`skipped=${result.skipped}`);
+  }
+  return fields.join(" ");
 }
 async function runUpgradeMigrations(context) {
+  requireConversationSqlDatabaseUrl(context);
   const results = [];
   for (const migration of MIGRATIONS) {
     context.io.info(`Running migration ${migration.name}...`);

package/dist/deployment.d.ts

@@ -2,3 +2,7 @@ export declare const JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
 export declare const JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
 export declare const JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
 export declare const LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
+/** Resolve the deployment version used for release and telemetry correlation. */
+export declare function getDeploymentServiceVersion(): string | undefined;
+/** Resolve deployment-scoped telemetry attributes from host environment. */
+export declare function getDeploymentTelemetryAttributes(): Record<string, string>;

package/dist/handlers/agent-dispatch.d.ts

@@ -1,3 +1,8 @@
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
 import type { WaitUntilFn } from "@/handlers/types";
+interface AgentDispatchHandlerOptions {
+    tracePropagation?: SandboxEgressTracePropagationConfig;
+}
 /** Handle the authenticated internal agent-dispatch callback. */
-export declare function POST(request: Request, waitUntil: WaitUntilFn): Promise<Response>;
+export declare function POST(request: Request, waitUntil: WaitUntilFn, options?: AgentDispatchHandlerOptions): Promise<Response>;
+export {};

package/dist/handlers/mcp-oauth-callback.d.ts

@@ -1,2 +1,7 @@
+import type { generateAssistantReply } from "@/chat/respond";
 import type { WaitUntilFn } from "@/handlers/types";
-export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn): Promise<Response>;
+interface McpOAuthCallbackOptions {
+    generateReply?: typeof generateAssistantReply;
+}
+export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn, options?: McpOAuthCallbackOptions): Promise<Response>;
+export {};

package/dist/handlers/oauth-callback.d.ts

@@ -1,2 +1,7 @@
 import type { WaitUntilFn } from "@/handlers/types";
-export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn): Promise<Response>;
+import type { generateAssistantReply } from "@/chat/respond";
+interface OAuthCallbackOptions {
+    generateReply?: typeof generateAssistantReply;
+}
+export declare function GET(request: Request, provider: string, waitUntil: WaitUntilFn, options?: OAuthCallbackOptions): Promise<Response>;
+export {};

package/dist/handlers/sandbox-egress-proxy.d.ts

@@ -1,6 +1,8 @@
 import { type SandboxEgressHttpInterceptor } from "@/chat/sandbox/egress-proxy";
+import type { SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress-tracing";
 interface SandboxEgressProxyOptions {
     interceptHttp?: SandboxEgressHttpInterceptor;
+    tracePropagation?: SandboxEgressTracePropagationConfig;
 }
 /** Handles Vercel Sandbox firewall egress proxy requests. */
 export declare function ALL(request: Request, options?: SandboxEgressProxyOptions): Promise<Response>;

package/dist/handlers/webhooks.d.ts

@@ -1,4 +1,5 @@
 import type { SlackAdapter } from "@chat-adapter/slack";
+import { type SlackWebhookServices } from "@/chat/ingress/slack-webhook";
 import { JuniorChat } from "@/chat/ingress/junior-chat";
 import type { WaitUntilFn } from "@/handlers/types";
 type LegacyChatSdkBot = JuniorChat<{
@@ -10,8 +11,9 @@ type LegacyChatSdkBot = JuniorChat<{
  * Slack production ingress persists messages into the durable conversation
  * mailbox and wakes the queue worker. The optional `legacyBot` parameter is
  * kept for integration tests that still exercise Chat SDK fixtures directly.
+ * The optional `services` parameter carries app-scoped runtime services.
  */
-export declare function handlePlatformWebhook(request: Request, platform: string, waitUntil: WaitUntilFn, legacyBot?: LegacyChatSdkBot): Promise<Response>;
+export declare function handlePlatformWebhook(request: Request, platform: string, waitUntil: WaitUntilFn, legacyBot?: LegacyChatSdkBot, services?: SlackWebhookServices): Promise<Response>;
 /** Handle a platform webhook request from the app route. */
-export declare function POST(request: Request, platform: string, waitUntil: WaitUntilFn): Promise<Response>;
+export declare function POST(request: Request, platform: string, waitUntil: WaitUntilFn, services?: SlackWebhookServices): Promise<Response>;
 export {};

package/dist/instrumentation.js

@@ -1,6 +1,8 @@
 import {
+  getDeploymentServiceVersion,
+  getDeploymentTelemetryAttributes,
   sentry_exports
-} from "./chunk-Z3YD6NHK.js";
+} from "./chunk-SJHUF3DP.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/instrumentation.ts
@@ -22,16 +24,28 @@ function initSentry() {
   }
   const dsn = process.env.SENTRY_DSN;
   const enableLogs = getBoolean(process.env.SENTRY_ENABLE_LOGS, Boolean(dsn));
+  const serviceVersion = getDeploymentServiceVersion();
+  const deploymentSpanAttributes = getDeploymentTelemetryAttributes();
   sentry_exports.init({
     dsn,
     environment: process.env.SENTRY_ENVIRONMENT ?? process.env.VERCEL_ENV ?? process.env.NODE_ENV,
-    release: process.env.SENTRY_RELEASE ?? process.env.VERCEL_GIT_COMMIT_SHA,
+    release: serviceVersion,
     tracesSampleRate: getSampleRate(process.env.SENTRY_TRACES_SAMPLE_RATE, 1),
     sendDefaultPii: true,
-    enabled: Boolean(dsn),
     enableLogs,
     registerEsmLoaderHooks: false,
     streamGenAiSpans: true,
+    // Keep deployment identity centralized so every emitted Sentry span carries it.
+    beforeSendSpan(span) {
+      if (Object.keys(deploymentSpanAttributes).length === 0) {
+        return span;
+      }
+      span.data = {
+        ...span.data,
+        ...deploymentSpanAttributes
+      };
+      return span;
+    },
     integrations: [
       sentry_exports.vercelAIIntegration({
         recordInputs: true,

package/dist/nitro.js

@@ -2,21 +2,20 @@ import {
   pluginCatalogConfigFromPluginSet,
   pluginHookRegistrationsFromPluginSet,
   resolveConversationWorkQueueTopic
-} from "./chunk-ICKIDP7G.js";
-import {
-  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
-  JUNIOR_HEARTBEAT_CRON_SCHEDULE,
-  JUNIOR_HEARTBEAT_ROUTE
-} from "./chunk-6YY4Q3D4.js";
-import "./chunk-XC33FJZN.js";
+} from "./chunk-YOHFWWBV.js";
+import "./chunk-YRDS7VKO.js";
 import {
   discoverInstalledPluginPackageContent,
   isValidPackageName,
   resolvePackageDir
 } from "./chunk-KVZL5NZS.js";
-import "./chunk-ZJQPA67D.js";
-import "./chunk-6GEYPE6T.js";
-import "./chunk-Z3YD6NHK.js";
+import "./chunk-GM7HTXYC.js";
+import "./chunk-3BYAPS6B.js";
+import {
+  JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
+  JUNIOR_HEARTBEAT_CRON_SCHEDULE,
+  JUNIOR_HEARTBEAT_ROUTE
+} from "./chunk-SJHUF3DP.js";
 import "./chunk-2KG3PWR4.js";
 
 // src/nitro.ts

package/dist/reporting/conversations.d.ts

@@ -1,3 +1,9 @@
+import type { AgentPluginConversationStatus, AgentPluginConversations, AgentPluginConversationSummary } from "@sentry/junior-plugin-api";
+import type { ConversationStore } from "@/chat/conversations/store";
+export type { AgentPluginConversationStatus, AgentPluginConversations, AgentPluginConversationSummary, };
+interface ConversationReaderOptions {
+    conversationStore?: ConversationStore;
+}
 export type ConversationReportStatus = "active" | "completed" | "failed" | "hung" | "superseded";
 export type ConversationSurface = "api" | "internal" | "scheduler" | "slack";
 export interface ConversationUsage {
@@ -109,8 +115,12 @@ export interface ConversationStatsReport {
     windowStart: string;
 }
 /** Read the recent conversation feed for reporting consumers. */
-export declare function readConversationFeed(): Promise<ConversationFeed>;
+export declare function readConversationFeed(options?: ConversationReaderOptions): Promise<ConversationFeed>;
 /** Read aggregate conversation statistics for reporting consumers. */
-export declare function readConversationStatsReport(): Promise<ConversationStatsReport>;
+export declare function readConversationStatsReport(options?: ConversationReaderOptions): Promise<ConversationStatsReport>;
+/** List recent conversation summaries for plugin operational reports. */
+export declare function listRecentConversationSummaries(options?: {
+    limit?: number;
+} & ConversationReaderOptions): Promise<AgentPluginConversationSummary[]>;
 /** Read one conversation transcript for reporting consumers. */
-export declare function readConversationReport(conversationId: string): Promise<ConversationReport>;
+export declare function readConversationReport(conversationId: string, options?: ConversationReaderOptions): Promise<ConversationReport>;