@sentry/junior 0.202.0 → 0.204.0

package/dist/store-C5qxF2ac.d.ts

@@ -0,0 +1,208 @@
+import { z } from "zod";
+import { Destination, Source, locationSchema } from "@sentry/junior-plugin-api";
+import "@earendil-works/pi-ai";
+//#region src/chat/conversation-privacy.d.ts
+type ConversationPrivacy = "public" | "private";
+//#endregion
+//#region src/chat/conversations/location.d.ts
+/** Validated Location associated with a Conversation. */
+type Location = z.output<typeof locationSchema>;
+//#endregion
+//#region src/chat/actor.d.ts
+declare const storedSlackActorSchema: z.ZodObject<{
+  email: z.ZodOptional<z.ZodString>;
+  fullName: z.ZodOptional<z.ZodString>;
+  platform: z.ZodOptional<z.ZodLiteral<"slack">>;
+  slackUserId: z.ZodOptional<z.ZodString>;
+  slackUserName: z.ZodOptional<z.ZodString>;
+  teamId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type StoredSlackActor = z.output<typeof storedSlackActorSchema>;
+//#endregion
+//#region src/chat/source.d.ts
+/** Legacy provider Source fields stored on a Conversation. */
+type SessionSource = Extract<Source, {
+  kind: "web";
+}> | Extract<Source, {
+  kind: "local";
+}> | Omit<Extract<Source, {
+  kind: "slack";
+}>, "messageTs">;
+//#endregion
+//#region src/usage-schema.d.ts
+declare const usageSchema: z.ZodObject<{
+  inputTokens: z.ZodOptional<z.ZodNumber>;
+  outputTokens: z.ZodOptional<z.ZodNumber>;
+  cachedInputTokens: z.ZodOptional<z.ZodNumber>;
+  cacheCreationTokens: z.ZodOptional<z.ZodNumber>;
+  reasoningTokens: z.ZodOptional<z.ZodNumber>;
+  totalTokens: z.ZodOptional<z.ZodNumber>;
+  cost: z.ZodOptional<z.ZodObject<{
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cacheRead: z.ZodOptional<z.ZodNumber>;
+    cacheWrite: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type Usage = z.output<typeof usageSchema>;
+//#endregion
+//#region src/chat/usage.d.ts
+/**
+ * Structured token and cost usage captured for a single agent turn.
+ *
+ * Mirrors the fields pi-ai emits on `AssistantMessage.usage` (see
+ * `@earendil-works/pi-ai` `Usage`) so diagnostics carry every counter the
+ * provider normalizes into the pi-ai shape as its own item. Renderers decide
+ * whether to display a breakdown or a single aggregate.
+ */
+type AgentTurnUsage = Usage;
+//#endregion
+//#region src/chat/conversations/store.d.ts
+type ConversationSource = "api" | "internal" | "local" | "plugin" | "resource_event" | "scheduler" | "slack" | "web";
+type ConversationStatus = "paused" | "failed" | "idle" | "pending" | "running";
+interface ConversationExecution {
+  lastCheckpointAtMs?: number;
+  lastEnqueuedAtMs?: number;
+  runId?: string;
+  status: ConversationStatus;
+  updatedAtMs?: number;
+}
+/**
+ * Durable Conversation owned by Junior.
+ *
+ * The final interface stores zero or one complete Location here. No Location
+ * means the Conversation stays in Junior's API and UI. A Location names the
+ * outside place where a provider can deliver the Conversation. A Run carries
+ * this Location when the agent or tools need it. Source stays about the input.
+ * Delivery is created for the Location and allows output to be sent there.
+ *
+ * `destination` and `sessionSource` temporarily duplicate parts of that model.
+ * Their field TODOs state when each legacy copy can be removed.
+ */
+interface Conversation {
+  channelName?: string;
+  conversationId: string;
+  createdAtMs: number;
+  destination?: Destination;
+  execution: ConversationExecution;
+  executionMetrics?: {
+    durationMs: number;
+    runId?: string;
+    usage?: AgentTurnUsage;
+  };
+  lastActivityAtMs: number;
+  /** Immutable parent Conversation. */
+  parentConversationId?: string;
+  /** Optional provider coordinates associated with this Conversation. */
+  location?: Location;
+  actor?: StoredSlackActor;
+  schemaVersion: 1;
+  source?: ConversationSource;
+  /**
+   * Structured inbound Source locator for this conversation session.
+   * Session-stable (threaded Slack keeps threadTs; channel-level turns omit
+   * it; never stores per-message ts). Set-once.
+   */
+  sessionSource?: SessionSource;
+  title?: string;
+  updatedAtMs: number;
+  /**
+   * When retention purged this conversation's content. Set means messages and
+   * events were deleted wholesale; reporting presents the transcript as expired
+   * rather than privacy-redacted (`../../../../../policies/data-redaction.md`).
+   */
+  transcriptPurgedAtMs?: number;
+  /** Confirmed Conversation visibility. Undefined means no confirmation exists. */
+  visibility?: ConversationPrivacy;
+}
+/** Persist and read durable conversation metadata for reporting surfaces. */
+interface ConversationStore {
+  /** Create one Conversation with an immutable parent. */
+  createChild(args: {
+    childConversationId: string;
+    parentConversationId: string;
+    nowMs?: number;
+    source?: ConversationSource;
+  }): Promise<void>;
+  get(args: {
+    conversationId: string;
+  }): Promise<Conversation | undefined>;
+  /** Resolve the durable conversation bound to one provider conversation. */
+  getConversationIdByProviderConversation(args: {
+    provider: string;
+    providerDestinationId: string;
+    providerTenantId: string;
+    providerConversationId: string;
+  }): Promise<string | undefined>;
+  /** Bind one provider conversation to its pre-existing durable conversation. */
+  bindProviderConversation(args: {
+    conversationId: string;
+    provider: string;
+    providerDestinationId: string;
+    providerTenantId: string;
+    providerConversationId: string;
+  }): Promise<void>;
+  /** Read confirmed public/private visibility for one destination. */
+  getDestinationVisibility(args: {
+    provider: string;
+    providerDestinationId: string;
+    providerTenantId?: string;
+  }): Promise<ConversationPrivacy | undefined>;
+  /**
+   * Resolve one Slack channel id from a known destination display name.
+   *
+   * Matches only destinations Junior already stored for this workspace. Exact
+   * name match after stripping a leading `#`. Returns undefined when missing
+   * or ambiguous. Does not scan Slack.
+   */
+  findSlackDestinationByName(args: {
+    channelName: string;
+    teamId: string;
+  }): Promise<{
+    channelId: string;
+    channelName?: string;
+  } | undefined>;
+  recordActivity(args: {
+    activityAtMs?: number;
+    channelName?: string;
+    conversationId: string;
+    destination?: Destination;
+    nowMs?: number;
+    actor?: StoredSlackActor;
+    source?: ConversationSource;
+    /** Source normalized to a stable session locator; set-once when absent. */
+    sessionSource?: Source;
+    title?: string;
+    /** Confirmed destination visibility; omit when unavailable. */
+    visibility?: ConversationPrivacy;
+  }): Promise<void>;
+  /**
+   * Materialize execution and usage aggregates beside canonical metadata.
+   * These fields serve reporting and runtime control, never history hydration.
+   */
+  recordExecution(args: {
+    channelName?: string;
+    conversationId: string;
+    createdAtMs: number;
+    destination?: Destination;
+    execution: ConversationExecution;
+    lastActivityAtMs: number;
+    metrics: {
+      durationMs: number;
+      usage?: AgentTurnUsage;
+    } | null;
+    actor?: StoredSlackActor;
+    source?: ConversationSource;
+    title?: string;
+    updatedAtMs: number;
+    /** Confirmed destination visibility; omit when unavailable. */
+    visibility?: ConversationPrivacy;
+  }): Promise<void>;
+  listByActivity(args?: {
+    limit?: number;
+    offset?: number;
+  }): Promise<Conversation[]>;
+}
+//#endregion
+export { ConversationStore as t };

package/dist/task-queue-CJIR4RF7.js

@@ -0,0 +1,136 @@
+import { f as logWarn } from "./logging-BzAk1S_s.js";
+import { a as signQueueMessage, i as QUEUE_SIGNATURE_MAX_AGE_MS, o as verifyQueueMessage, s as createVercelQueueClient } from "./vercel-queue-DIkVcfK4.js";
+import { o as runWithTurnRequestDeadline } from "./job-queue-Drn_LXlM.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { handleCallback, registerDevConsumer } from "@vercel/queue";
+//#region src/chat/queue/callback.ts
+/** Shared Vercel Queue callback wiring for signed messages. */
+/** Build the HTTP callback and local-dev consumer for one signed queue. */
+function queueCallback(options) {
+	const handler = async (value, metadata) => {
+		if (options.skip?.(metadata)) return;
+		const checked = options.verify(value);
+		if (checked.status === "rejected") {
+			options.onRejected(checked.reason, metadata);
+			return;
+		}
+		if (checked.status === "unavailable") throw new Error(`Queue message verification unavailable: ${checked.reason}`);
+		try {
+			await runWithTurnRequestDeadline(() => options.run(checked.message, metadata));
+		} catch (error) {
+			const reason = options.permanentError?.(error);
+			if (!reason) throw error;
+			options.onRejected(reason, metadata, error);
+		}
+	};
+	const retry = (error, metadata) => {
+		const reason = options.permanentError?.(error);
+		if (reason) {
+			options.onRejected(reason, metadata, error);
+			return { acknowledge: true };
+		}
+		if (options.maxDeliveries !== null && metadata.deliveryCount >= options.maxDeliveries) return { acknowledge: true };
+	};
+	const visibility = options.visibilityTimeoutSeconds === void 0 ? {} : { visibilityTimeoutSeconds: options.visibilityTimeoutSeconds };
+	return {
+		create: () => handleCallback(handler, {
+			retry,
+			...visibility
+		}),
+		registerDev: () => {
+			if (process.env.NODE_ENV !== "development") return;
+			return registerDevConsumer({
+				client: createVercelQueueClient(),
+				consumerGroup: options.consumerGroup,
+				handler,
+				retry,
+				topic: options.topic,
+				...visibility
+			});
+		}
+	};
+}
+//#endregion
+//#region src/chat/plugins/task-queue.ts
+/**
+* Delivery for plugin-registered tasks.
+*
+* Plugins register named tasks. This module owns the shared signed message,
+* send path, and HTTP/local callback. Core keeps one topic and one runner.
+*/
+/** Deploy topic name. Keep stable for Vercel queue wiring. */
+const PLUGIN_TASK_QUEUE_TOPIC = "junior_plugin_tasks";
+const PLUGIN_TASK_DEV_CONSUMER_GROUP = "junior_plugin_tasks_dev";
+const PLUGIN_TASK_MAX_DELIVERIES = 5;
+const PLUGIN_TASK_SIGN_CONTEXT = "junior.plugin_task_queue.v1";
+const PLUGIN_TASK_SIGN_VERSION = "v1";
+const pluginTaskParamsSchema = z.object({
+	conversationId: z.string().min(1),
+	sessionId: z.string().min(1)
+}).strict();
+const pluginTaskSign = {
+	context: PLUGIN_TASK_SIGN_CONTEXT,
+	schema: z.object({
+		name: z.string().min(1),
+		params: pluginTaskParamsSchema,
+		plugin: z.string().min(1)
+	}).strict(),
+	signatureVersion: PLUGIN_TASK_SIGN_VERSION,
+	parts: (message) => [
+		message.plugin,
+		message.name,
+		message.params.conversationId,
+		message.params.sessionId
+	]
+};
+/** Build the stable id used for delivery dedupe and tracing. */
+function pluginTaskId(args) {
+	return `plugin-task_${createHash("sha256").update(args.plugin).update("\0").update(args.name).update("\0").update(args.params.conversationId).update("\0").update(args.params.sessionId).digest("hex").slice(0, 32)}`;
+}
+/** Sign a plugin task message for tests and local checks. */
+function signPluginTaskQueueMessage(message, nowMs = Date.now()) {
+	return signQueueMessage(pluginTaskSign, message, nowMs);
+}
+function verifyPluginTaskQueueMessage(value, nowMs = Date.now()) {
+	return verifyQueueMessage(pluginTaskSign, value, nowMs);
+}
+function logPluginTaskQueueMessageRejected(reason, metadata) {
+	logWarn("plugin.task.queue_message.rejected", {
+		"app.queue.consumer_group": metadata.consumerGroup,
+		"app.queue.delivery_count": metadata.deliveryCount,
+		"app.queue.message_id": metadata.messageId,
+		"app.queue.reject_reason": reason,
+		"app.queue.topic_name": metadata.topicName
+	});
+}
+function pluginTaskCallback() {
+	return queueCallback({
+		consumerGroup: PLUGIN_TASK_DEV_CONSUMER_GROUP,
+		maxDeliveries: PLUGIN_TASK_MAX_DELIVERIES,
+		onRejected: logPluginTaskQueueMessageRejected,
+		run: async (message) => {
+			const { processPluginTask } = await import("./task-runner-D-O3A-Cp.js").then((n) => n.r);
+			await processPluginTask(message);
+		},
+		topic: PLUGIN_TASK_QUEUE_TOPIC,
+		verify: verifyPluginTaskQueueMessage
+	});
+}
+/** Send one plugin task through the shared signed delivery path. */
+async function sendVercelPluginTask(message) {
+	await createVercelQueueClient().send(PLUGIN_TASK_QUEUE_TOPIC, signPluginTaskQueueMessage(message), {
+		idempotencyKey: pluginTaskId(message),
+		retentionSeconds: QUEUE_SIGNATURE_MAX_AGE_MS / 1e3
+	});
+}
+/** Create the HTTP callback for plugin tasks. */
+function createVercelPluginTaskCallback() {
+	return pluginTaskCallback().create();
+}
+/** Register the local-dev consumer for plugin tasks. */
+function registerVercelPluginTaskDevConsumer() {
+	return pluginTaskCallback().registerDev();
+}
+//#endregion
+export { registerVercelPluginTaskDevConsumer as a, pluginTaskParamsSchema as i, createVercelPluginTaskCallback as n, sendVercelPluginTask as o, pluginTaskId as r, queueCallback as s, PLUGIN_TASK_QUEUE_TOPIC as t };