@sentry/junior 0.96.0 → 0.97.0

package/dist/chunk-LUAE4MGW.js

@@ -0,0 +1,199 @@
+import {
+  usageSchema
+} from "./chunk-PDO5BLNM.js";
+
+// src/api/conversations/schema.ts
+import { z } from "zod";
+var conversationReportStatusSchema = z.enum([
+  "active",
+  "completed",
+  "failed",
+  "hung"
+]);
+var conversationSurfaceSchema = z.enum([
+  "api",
+  "internal",
+  "scheduler",
+  "slack"
+]);
+var conversationUsageSchema = usageSchema;
+var actorIdentitySchema = z.object({
+  email: z.string().optional(),
+  fullName: z.string().optional(),
+  slackUserId: z.string().optional(),
+  slackUserName: z.string().optional()
+}).strict();
+var conversationSummaryReportSchema = z.object({
+  displayTitle: z.string(),
+  cumulativeDurationMs: z.number(),
+  cumulativeUsage: conversationUsageSchema.optional(),
+  conversationId: z.string(),
+  status: conversationReportStatusSchema,
+  startedAt: z.string(),
+  lastSeenAt: z.string(),
+  lastProgressAt: z.string(),
+  surface: conversationSurfaceSchema,
+  actorIdentity: actorIdentitySchema.optional(),
+  channel: z.string().optional(),
+  channelName: z.string().optional(),
+  channelNameRedacted: z.boolean().optional(),
+  sentryTraceUrl: z.string().optional(),
+  traceId: z.string().optional()
+}).strict();
+var transcriptPartTypeSchema = z.enum([
+  "text",
+  "thinking",
+  "tool_call",
+  "tool_result",
+  "unknown"
+]);
+var transcriptPartSchema = z.object({
+  bytes: z.number().optional(),
+  chars: z.number().optional(),
+  id: z.string().optional(),
+  input: z.unknown().optional(),
+  inputKeys: z.array(z.string()).optional(),
+  inputSizeBytes: z.number().optional(),
+  inputSizeChars: z.number().optional(),
+  inputType: z.string().optional(),
+  name: z.string().optional(),
+  output: z.unknown().optional(),
+  outputKeys: z.array(z.string()).optional(),
+  outputSizeBytes: z.number().optional(),
+  outputSizeChars: z.number().optional(),
+  outputType: z.string().optional(),
+  redacted: z.boolean().optional(),
+  sourceType: z.string().optional(),
+  text: z.string().optional(),
+  type: transcriptPartTypeSchema
+}).strict();
+var transcriptRoleSchema = z.enum([
+  "assistant",
+  "system",
+  "tool",
+  "toolResult",
+  "unknown",
+  "user"
+]);
+var transcriptMessageSchema = z.object({
+  parts: z.array(transcriptPartSchema),
+  role: transcriptRoleSchema,
+  timestamp: z.number().optional()
+}).strict();
+var conversationActivityStatusSchema = z.enum([
+  "aborted",
+  "completed",
+  "error",
+  "running",
+  "success"
+]);
+var conversationSubagentActivityReportSchema = z.object({
+  type: z.literal("subagent"),
+  createdAt: z.string(),
+  endedAt: z.string().optional(),
+  id: z.string(),
+  modelId: z.string().optional(),
+  outcome: z.enum(["success", "error", "aborted"]).optional(),
+  parentToolCallId: z.string().optional(),
+  reasoningLevel: z.string().optional(),
+  status: conversationActivityStatusSchema,
+  subagentKind: z.string(),
+  transcriptAvailable: z.boolean().optional()
+}).strict();
+var conversationToolActivityReportSchema = z.object({
+  type: z.literal("tool_execution"),
+  args: z.unknown().optional(),
+  createdAt: z.string(),
+  id: z.string(),
+  inputKeys: z.array(z.string()).optional(),
+  inputSizeBytes: z.number().optional(),
+  inputSizeChars: z.number().optional(),
+  inputType: z.string().optional(),
+  redacted: z.boolean().optional(),
+  status: conversationActivityStatusSchema,
+  subagents: z.array(conversationSubagentActivityReportSchema),
+  toolCallId: z.string(),
+  toolName: z.string()
+}).strict();
+var conversationActivityReportSchema = z.discriminatedUnion("type", [
+  conversationToolActivityReportSchema,
+  conversationSubagentActivityReportSchema
+]);
+var conversationDetailReportSchema = conversationSummaryReportSchema.extend({
+  activity: z.array(conversationActivityReportSchema).optional(),
+  transcriptAvailable: z.boolean(),
+  transcriptMetadata: z.array(transcriptMessageSchema).optional(),
+  transcriptMessageCount: z.number().optional(),
+  transcriptRedacted: z.boolean().optional(),
+  transcriptRedactionReason: z.literal("non_public_conversation").optional(),
+  transcriptExpired: z.boolean().optional(),
+  transcriptExpiredAt: z.string().optional(),
+  transcript: z.array(transcriptMessageSchema),
+  generatedAt: z.string(),
+  sentryConversationUrl: z.string().optional()
+}).strict();
+var conversationSubagentTranscriptReportSchema = z.object({
+  type: z.literal("subagent"),
+  createdAt: z.string(),
+  endedAt: z.string().optional(),
+  id: z.string(),
+  modelId: z.string().optional(),
+  outcome: z.enum(["success", "error", "aborted"]).optional(),
+  parentToolCallId: z.string().optional(),
+  reasoningLevel: z.string().optional(),
+  status: conversationActivityStatusSchema,
+  subagentConversationId: z.string().optional(),
+  subagentKind: z.string(),
+  subagentSentryConversationUrl: z.string().optional(),
+  transcript: z.array(transcriptMessageSchema),
+  transcriptAvailable: z.boolean(),
+  transcriptMessageCount: z.number().optional(),
+  transcriptRedacted: z.boolean().optional(),
+  transcriptRedactionReason: z.literal("non_public_conversation").optional(),
+  transcriptExpired: z.boolean().optional(),
+  transcriptExpiredAt: z.string().optional(),
+  unavailableReason: z.enum(["missing_transcript_range", "missing_transcript_ref", "not_found"]).optional()
+}).strict();
+var conversationFeedSchema = z.object({
+  conversations: z.array(conversationSummaryReportSchema),
+  source: z.literal("conversation_index"),
+  generatedAt: z.string()
+}).strict();
+var conversationStatsItemSchema = z.object({
+  active: z.number(),
+  conversations: z.number(),
+  durationMs: z.number(),
+  failed: z.number(),
+  hung: z.number(),
+  label: z.string(),
+  costUsd: z.number().optional(),
+  tokens: z.number().optional()
+}).strict();
+var conversationStatsReportSchema = z.object({
+  active: z.number(),
+  conversations: z.number(),
+  durationMs: z.number(),
+  failed: z.number(),
+  generatedAt: z.string(),
+  hung: z.number(),
+  locations: z.array(conversationStatsItemSchema),
+  actors: z.array(conversationStatsItemSchema),
+  sampleLimit: z.number(),
+  sampleSize: z.number(),
+  source: z.literal("conversation_index"),
+  costUsd: z.number().optional(),
+  tokens: z.number().optional(),
+  truncated: z.boolean(),
+  windowEnd: z.string(),
+  windowStart: z.string()
+}).strict();
+
+export {
+  actorIdentitySchema,
+  conversationSummaryReportSchema,
+  conversationDetailReportSchema,
+  conversationSubagentTranscriptReportSchema,
+  conversationFeedSchema,
+  conversationStatsItemSchema,
+  conversationStatsReportSchema
+};

package/dist/{chunk-GY34VGP5.js → chunk-LVA4I4H7.js}

@@ -7,6 +7,9 @@ import {
   parseSlackTeamId
 } from "./chunk-7FBGKXPE.js";
 
+// src/chat/conversation-privacy.ts
+import { AsyncLocalStorage } from "async_hooks";
+
 // src/chat/slack/context.ts
 import { z } from "zod";
 function toTrimmedSlackString(value) {
@@ -95,7 +98,6 @@ function resolveSlackChannelIdFromMessage(message) {
 }
 
 // src/chat/conversation-privacy.ts
-import { AsyncLocalStorage } from "async_hooks";
 var SAFE_METADATA_KEY_LIMIT = 20;
 var conversationPrivacyStorage = new AsyncLocalStorage();
 function privateNarrowingFromChannelId(channelId) {

package/dist/chunk-LVUKF5CE.js

@@ -0,0 +1,63 @@
+import {
+  getClient
+} from "./chunk-6GWA276C.js";
+
+// src/chat/sentry-links.ts
+function getSentryOrgSlug() {
+  const slug = process.env.SENTRY_ORG_SLUG?.trim();
+  return slug || void 0;
+}
+function isSentrySaasDsnHost(host) {
+  return host === "sentry.io" || host.endsWith(".sentry.io");
+}
+function buildSentryWebBaseUrl(dsn) {
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return "https://sentry.io";
+  }
+  const port = dsn.port ? `:${dsn.port}` : "";
+  const path = dsn.path ? `/${dsn.path}` : "";
+  return `${dsn.protocol}://${dsn.host}${port}${path}`;
+}
+function buildSentryConversationUrl(conversationId) {
+  const client = getClient();
+  const dsn = client?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedId = encodeURIComponent(conversationId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path = `explore/conversations/${encodedId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+function buildSentryTraceUrl(traceId) {
+  const client = getClient();
+  const dsn = client?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedTraceId = encodeURIComponent(traceId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path = `performance/trace/${encodedTraceId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+}
+
+export {
+  buildSentryConversationUrl,
+  buildSentryTraceUrl
+};

package/dist/{chunk-AAZXTVJT.js → chunk-NG2AV7IB.js}

@@ -1,76 +1,9 @@
 import {
   normalizeSlackConversationId
-} from "./chunk-S5KZ5LPG.js";
+} from "./chunk-WTYEKPXU.js";
 import {
   parseSlackThreadId
-} from "./chunk-GY34VGP5.js";
-import {
-  getClient
-} from "./chunk-6GWA276C.js";
-
-// src/handlers/health.ts
-function GET() {
-  return Response.json({
-    status: "ok",
-    service: "junior",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-
-// src/chat/sentry-links.ts
-function getSentryOrgSlug() {
-  const slug = process.env.SENTRY_ORG_SLUG?.trim();
-  return slug || void 0;
-}
-function isSentrySaasDsnHost(host) {
-  return host === "sentry.io" || host.endsWith(".sentry.io");
-}
-function buildSentryWebBaseUrl(dsn) {
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return "https://sentry.io";
-  }
-  const port = dsn.port ? `:${dsn.port}` : "";
-  const path = dsn.path ? `/${dsn.path}` : "";
-  return `${dsn.protocol}://${dsn.host}${port}${path}`;
-}
-function buildSentryConversationUrl(conversationId) {
-  const client = getClient();
-  const dsn = client?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const encodedId = encodeURIComponent(conversationId);
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  const path = `explore/conversations/${encodedId}/?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
-}
-function buildSentryTraceUrl(traceId) {
-  const client = getClient();
-  const dsn = client?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const encodedTraceId = encodeURIComponent(traceId);
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  const path = `performance/trace/${encodedTraceId}/?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
-}
+} from "./chunk-LVA4I4H7.js";
 
 // src/chat/slack/conversation-context.ts
 function normalizeConversationName(type, channelName) {
@@ -155,9 +88,6 @@ function formatSlackConversationRedactedLabel(context) {
 }
 
 export {
-  GET,
-  buildSentryConversationUrl,
-  buildSentryTraceUrl,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,

package/dist/chunk-ON6YKIQ7.js

@@ -0,0 +1,260 @@
+import {
+  formatSlackConversationRedactedLabel,
+  resolveSlackConversationContextFromThreadId
+} from "./chunk-NG2AV7IB.js";
+import {
+  getDb,
+  juniorConversations,
+  juniorDestinations,
+  juniorIdentities
+} from "./chunk-35BNLDOJ.js";
+import {
+  parseSlackThreadId,
+  resolveConversationPrivacy
+} from "./chunk-LVA4I4H7.js";
+
+// src/api/conversations/list.query.ts
+import { asc, desc, eq, isNull } from "drizzle-orm";
+
+// src/api/conversations/shared.ts
+function slackStatsLocationLabel(input) {
+  const channelId = input.channel;
+  if (!channelId) return void 0;
+  if (input.channelNameRedacted && input.channelName) {
+    return input.channelName;
+  }
+  const name = input.channelName?.replace(/^#/, "");
+  if (channelId.startsWith("D")) return "Direct Message";
+  if (channelId.startsWith("C")) return name ? `#${name}` : "Public Channel";
+  if (channelId.startsWith("G")) {
+    if (name?.startsWith("mpdm-")) return "Group DM";
+    return "Private Channel";
+  }
+  return name || channelId;
+}
+function surfaceFallbackLabel(surface) {
+  if (surface === "scheduler") return "Scheduler";
+  if (surface === "api") return "API";
+  if (surface === "internal") return "Internal";
+  return "Conversation";
+}
+
+// src/api/conversations/projection.ts
+var HUNG_TURN_PROGRESS_MS = 5 * 60 * 1e3;
+var PRIVATE_CONVERSATION_LABEL = "Private Conversation";
+function privateConversationLabel(slackConversation) {
+  if (!slackConversation) {
+    return PRIVATE_CONVERSATION_LABEL;
+  }
+  return slackConversation.visibility === "private" ? formatSlackConversationRedactedLabel(slackConversation) ?? PRIVATE_CONVERSATION_LABEL : PRIVATE_CONVERSATION_LABEL;
+}
+function surfaceFromConversationId(conversationId) {
+  if (parseSlackThreadId(conversationId)) return "slack";
+  if (conversationId.startsWith("scheduler:")) return "scheduler";
+  if (conversationId.startsWith("api:")) return "api";
+  return "internal";
+}
+function surfaceFromSource(source, conversationId) {
+  if (source === "slack" || source === "api" || source === "scheduler") {
+    return source;
+  }
+  return surfaceFromConversationId(conversationId);
+}
+function actorIdentityReport(actor) {
+  if (!actor) return void 0;
+  const identity = {
+    ...actor.email !== void 0 ? { email: actor.email } : {},
+    ...actor.fullName !== void 0 ? { fullName: actor.fullName } : {},
+    ...actor.slackUserId !== void 0 ? { slackUserId: actor.slackUserId } : {},
+    ...actor.slackUserName !== void 0 ? { slackUserName: actor.slackUserName } : {}
+  };
+  return Object.keys(identity).length > 0 ? identity : void 0;
+}
+function statusFromConversation(conversation, nowMs) {
+  if (conversation.execution.status === "idle") {
+    return "completed";
+  }
+  if (conversation.execution.status === "failed") {
+    return "failed";
+  }
+  const updatedAtMs = conversation.execution.updatedAtMs ?? conversation.updatedAtMs;
+  if (conversation.execution.status === "running" && nowMs - updatedAtMs > HUNG_TURN_PROGRESS_MS) {
+    return "hung";
+  }
+  return "active";
+}
+function titleFromConversation(args) {
+  const slackThread = parseSlackThreadId(args.conversation.conversationId);
+  const effectiveChannelName = args.conversation.channelName;
+  const slackConversation = resolveSlackConversationContextFromThreadId({
+    threadId: args.conversation.conversationId,
+    channelName: effectiveChannelName
+  });
+  const privateLabel = resolveConversationPrivacy({
+    conversationId: args.conversation.conversationId,
+    visibility: args.conversation.visibility
+  }) !== "public" ? privateConversationLabel(slackConversation) : void 0;
+  return privateLabel ?? args.conversation.title ?? slackStatsLocationLabel({
+    channel: slackThread?.channelId,
+    channelName: effectiveChannelName
+  }) ?? surfaceFallbackLabel(args.surface);
+}
+function channelNameFromConversation(conversation) {
+  const effectiveChannelName = conversation.channelName;
+  const slackThread = parseSlackThreadId(conversation.conversationId);
+  if (!effectiveChannelName && !slackThread) {
+    return void 0;
+  }
+  const slackConversation = resolveSlackConversationContextFromThreadId({
+    threadId: conversation.conversationId,
+    channelName: effectiveChannelName
+  });
+  if (resolveConversationPrivacy({
+    conversationId: conversation.conversationId,
+    visibility: conversation.visibility
+  }) !== "public") {
+    return privateConversationLabel(slackConversation);
+  }
+  return effectiveChannelName;
+}
+function channelNameRedactedFromConversation(conversation) {
+  const effectiveChannelName = conversation.channelName;
+  const slackThread = parseSlackThreadId(conversation.conversationId);
+  if (!effectiveChannelName && !slackThread) {
+    return false;
+  }
+  return resolveConversationPrivacy({
+    conversationId: conversation.conversationId,
+    visibility: conversation.visibility
+  }) !== "public";
+}
+function conversationSummaryFromStoredConversation(args) {
+  const { conversation, durationMs, nowMs, usage } = args;
+  const surface = surfaceFromSource(
+    conversation.source,
+    conversation.conversationId
+  );
+  const actorIdentity = actorIdentityReport(conversation.actor);
+  const slackThread = parseSlackThreadId(conversation.conversationId);
+  const channelName = channelNameFromConversation(conversation);
+  const channelNameRedacted = channelNameRedactedFromConversation(conversation);
+  return {
+    conversationId: conversation.conversationId,
+    cumulativeDurationMs: durationMs,
+    displayTitle: titleFromConversation({ conversation, surface }),
+    lastProgressAt: new Date(
+      conversation.execution.updatedAtMs ?? conversation.updatedAtMs
+    ).toISOString(),
+    lastSeenAt: new Date(conversation.lastActivityAtMs).toISOString(),
+    startedAt: new Date(conversation.createdAtMs).toISOString(),
+    status: statusFromConversation(conversation, nowMs),
+    surface,
+    ...usage ? { cumulativeUsage: usage } : {},
+    ...actorIdentity ? { actorIdentity } : {},
+    ...slackThread ? { channel: slackThread.channelId } : {},
+    ...channelName ? { channelName } : {},
+    ...channelNameRedacted ? { channelNameRedacted: true } : {}
+  };
+}
+
+// src/api/conversations/list.query.ts
+var CONVERSATION_FEED_LIMIT = 50;
+async function conversationRows(db, limit) {
+  return db.select({
+    conversation: juniorConversations,
+    destinationVisibility: juniorDestinations.visibility,
+    identityDisplayName: juniorIdentities.displayName,
+    identityEmail: juniorIdentities.email,
+    identityHandle: juniorIdentities.handle,
+    identityProvider: juniorIdentities.provider,
+    identitySubjectId: juniorIdentities.providerSubjectId,
+    identityTenantId: juniorIdentities.providerTenantId
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq(juniorDestinations.id, juniorConversations.destinationId)
+  ).leftJoin(
+    juniorIdentities,
+    eq(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).where(isNull(juniorConversations.parentConversationId)).orderBy(
+    desc(juniorConversations.lastActivityAt),
+    asc(juniorConversations.conversationId)
+  ).limit(limit);
+}
+function conversationFromRow(row) {
+  const value = row.conversation;
+  const actor = row.identityProvider === "slack" ? {
+    platform: "slack",
+    ...row.identityEmail ? { email: row.identityEmail } : {},
+    ...row.identityDisplayName ? { fullName: row.identityDisplayName } : {},
+    ...row.identitySubjectId ? { slackUserId: row.identitySubjectId } : {},
+    ...row.identityHandle ? { slackUserName: row.identityHandle } : {},
+    ...row.identityTenantId ? { teamId: row.identityTenantId } : {}
+  } : void 0;
+  return {
+    schemaVersion: 1,
+    conversationId: value.conversationId,
+    createdAtMs: value.createdAt.getTime(),
+    lastActivityAtMs: value.lastActivityAt.getTime(),
+    updatedAtMs: value.updatedAt.getTime(),
+    execution: {
+      status: value.executionStatus,
+      ...value.runId ? { runId: value.runId } : {},
+      ...value.executionUpdatedAt ? { updatedAtMs: value.executionUpdatedAt.getTime() } : {}
+    },
+    ...actor ? { actor } : {},
+    ...value.channelName ? { channelName: value.channelName } : {},
+    ...value.source ? { source: value.source } : {},
+    ...value.title ? { title: value.title } : {},
+    ...value.transcriptPurgedAt ? { transcriptPurgedAtMs: value.transcriptPurgedAt.getTime() } : {},
+    ...row.destinationVisibility ? {
+      visibility: row.destinationVisibility === "public" ? "public" : "private"
+    } : {}
+  };
+}
+async function readConversationRecordFromSql(conversationId) {
+  const db = getDb();
+  const rows = await db.select({
+    conversation: juniorConversations,
+    destinationVisibility: juniorDestinations.visibility,
+    identityDisplayName: juniorIdentities.displayName,
+    identityEmail: juniorIdentities.email,
+    identityHandle: juniorIdentities.handle,
+    identityProvider: juniorIdentities.provider,
+    identitySubjectId: juniorIdentities.providerSubjectId,
+    identityTenantId: juniorIdentities.providerTenantId
+  }).from(juniorConversations).leftJoin(
+    juniorDestinations,
+    eq(juniorDestinations.id, juniorConversations.destinationId)
+  ).leftJoin(
+    juniorIdentities,
+    eq(juniorIdentities.id, juniorConversations.actorIdentityId)
+  ).where(eq(juniorConversations.conversationId, conversationId)).limit(1);
+  const row = rows[0];
+  return row ? {
+    conversation: conversationFromRow(row),
+    durationMs: row.conversation.durationMs,
+    usage: row.conversation.usage
+  } : void 0;
+}
+async function readConversationFeedFromSql(limit = CONVERSATION_FEED_LIMIT) {
+  const nowMs = Date.now();
+  const rows = await conversationRows(getDb(), limit);
+  return {
+    conversations: rows.map(
+      (row) => conversationSummaryFromStoredConversation({
+        conversation: conversationFromRow(row),
+        durationMs: row.conversation.durationMs,
+        nowMs,
+        usage: row.conversation.usage ?? void 0
+      })
+    ),
+    generatedAt: new Date(nowMs).toISOString(),
+    source: "conversation_index"
+  };
+}
+
+export {
+  conversationSummaryFromStoredConversation,
+  readConversationRecordFromSql,
+  readConversationFeedFromSql
+};

package/dist/chunk-PDO5BLNM.js

@@ -0,0 +1,22 @@
+// src/usage-schema.ts
+import { z } from "zod";
+var usageCostSchema = z.object({
+  input: z.number().finite().nonnegative().optional(),
+  output: z.number().finite().nonnegative().optional(),
+  cacheRead: z.number().finite().nonnegative().optional(),
+  cacheWrite: z.number().finite().nonnegative().optional(),
+  total: z.number().finite().nonnegative().optional()
+}).strict();
+var usageSchema = z.object({
+  inputTokens: z.number().int().nonnegative().optional(),
+  outputTokens: z.number().int().nonnegative().optional(),
+  cachedInputTokens: z.number().int().nonnegative().optional(),
+  cacheCreationTokens: z.number().int().nonnegative().optional(),
+  reasoningTokens: z.number().int().nonnegative().optional(),
+  totalTokens: z.number().int().nonnegative().optional(),
+  cost: usageCostSchema.optional()
+}).strict();
+
+export {
+  usageSchema
+};

package/dist/chunk-QNVHH5PU.js

@@ -0,0 +1,20 @@
+import {
+  healthReportSchema
+} from "./chunk-CEA3A3UA.js";
+
+// src/handlers/health.ts
+function readHealthReport() {
+  return healthReportSchema.parse({
+    status: "ok",
+    service: "junior",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function GET() {
+  return Response.json(readHealthReport());
+}
+
+export {
+  readHealthReport,
+  GET
+};