@mono-agent/web 0.19.1 → 0.20.0

package/dist/service.js

@@ -1,6 +1,6 @@
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { DEFAULT_AGENT_ATTACHMENT_MAX_BYTES, DEFAULT_AGENT_ATTACHMENT_MIME_ALLOWLIST, toolNameLeaf, } from "@mono-agent/agent-contracts";
+import { DEFAULT_AGENT_ATTACHMENT_MAX_BYTES, DEFAULT_AGENT_ATTACHMENT_MIME_ALLOWLIST, createChannelUserCancelReason, isChannelUserCancelReason, toolNameLeaf, } from "@mono-agent/agent-contracts";
 import { EFFORT_LEVELS } from "@mono-agent/config";
 import { WEB_API_VERSION, WEB_MAX_CONCURRENT_UPLOADS, WEB_MAX_ACTIVE_ATTACHMENT_TURN_BYTES, WEB_MAX_FILES_PER_TURN, WEB_MAX_STAGED_UPLOAD_BYTES, WEB_MAX_STAGED_UPLOADS, WEB_MAX_QUEUED_ATTACHMENT_TURNS, WEB_MAX_TURN_TEXT_CHARACTERS, WEB_MAX_TURN_ATTACHMENT_BYTES, WEB_STAGED_UPLOAD_TTL_MS, } from "./contracts.js";
 import { discoverOperatorAgents, } from "./discovery.js";
@@ -8,11 +8,12 @@ import { errorCode, errorMessage, WebConsoleError } from "./errors.js";
 import { OperatorClient } from "./operator-client.js";
 import { generateWebPushIdentity, normalizeWebPushEndpoint, resolveWebPushSubject, validateWebPushEndpoint, validateWebPushKeys, WebPushDispatcher, WEB_PUSH_SERVICE_WORKER_VERSION, } from "./push.js";
 import { acquireWebStateLease, prepareWebStatePaths } from "./state-paths.js";
-import { toWebAttachment, WebStore, } from "./store.js";
+import { cronChannelReadOnlyError, toWebAttachment, WebStore, notificationPushLogicalKey, } from "./store.js";
 const DEFAULT_DISCOVERY_INTERVAL_MS = 5_000;
 const DEFAULT_PURGE_INTERVAL_MS = 60 * 60 * 1_000;
 const INFO_TIMEOUT_MS = 2_500;
 const ASK_DISCOVERY_TIMEOUT_MS = 120_000;
+const REPLY_ACCESS_TTL_MS = 10 * 60 * 1_000;
 function formatQuotedTurn(quote, text) {
     const blockquote = quote
         .trim()
@@ -36,6 +37,7 @@ export class WebService {
     pushIdentity;
     pushDispatcher;
     pushAckKey = randomBytes(32);
+    replyAccessKey;
     askWatches = new Map();
     connections = new Map();
     discoveryTimer;
@@ -45,11 +47,12 @@ export class WebService {
     refreshController;
     eventSequence = 0;
     stopped = false;
-    constructor(store, lease, options, pushIdentity, pushSubject) {
+    constructor(store, lease, options, pushIdentity, pushSubject, replyAccessKey) {
         this.store = store;
         this.lease = lease;
         this.options = options;
         this.pushIdentity = pushIdentity;
+        this.replyAccessKey = replyAccessKey;
         this.attachmentTurnBudget = new WeightedTurnBudget(options.maxActiveAttachmentTurnBytes ?? WEB_MAX_ACTIVE_ATTACHMENT_TURN_BYTES, options.maxQueuedAttachmentTurns ?? WEB_MAX_QUEUED_ATTACHMENT_TURNS);
         this.pushDispatcher = new WebPushDispatcher(store, pushIdentity, pushSubject, {
             ...(options.pushSendImpl === undefined ? {} : { send: options.pushSendImpl }),
@@ -83,8 +86,9 @@ export class WebService {
         let service;
         try {
             const pushIdentity = store.ensureWebPushIdentity(generateWebPushIdentity);
+            const replyAccessKey = Buffer.from(store.ensureReplyAccessKey(() => randomBytes(32).toString("base64url")), "base64url");
             const pushSubject = resolveWebPushSubject(options.env?.MONO_AGENT_WEB_PUSH_SUBJECT);
-            service = new WebService(store, lease, options, pushIdentity, pushSubject);
+            service = new WebService(store, lease, options, pushIdentity, pushSubject, replyAccessKey);
             await store.purgePartialUploadFiles();
             await service.purgeOrphans();
             await service.refreshAgents();
@@ -132,7 +136,78 @@ export class WebService {
         const detail = this.store.getThreadDetail(id);
         if (detail === undefined)
             throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
-        return detail;
+        return this.decorateThreadDetail(detail);
+    }
+    threadsPage(input) {
+        return this.store.listThreadsPage(input);
+    }
+    messagePage(threadId, input) {
+        const page = this.store.listMessagesPage(threadId, input);
+        return { ...page, messages: page.messages.map((message) => this.decorateMessage(message)) };
+    }
+    /**
+     * Re-mint a browser capability from the authoritative durable message. The
+     * HTTP route supplies exact-origin console authority; stale access tokens are
+     * deliberately not accepted as renewable credentials.
+     */
+    replyPartAccess(threadId, messageId, partId, type) {
+        const { message, part } = this.requireReplyPart(threadId, messageId, partId, type);
+        this.assertReplyPartRetained(part);
+        return this.decorateReplyPart(message, part);
+    }
+    async replyAttachment(threadId, messageId, partId, expires, token, signal) {
+        const { thread, part } = this.authorizeReplyPart(threadId, messageId, partId, "attachment", expires, token);
+        const connection = this.connections.get(thread.sourceId);
+        if (connection === undefined || connection.info.replyAttachments?.version !== 1) {
+            throw new WebConsoleError("reply_attachment_unavailable", "The attachment source is offline or incompatible.", 409);
+        }
+        const attachment = {
+            type: "attachment",
+            id: part.id,
+            reference: { scheme: "mono-agent-artifact", id: part.artifactId },
+            name: part.name,
+            mediaType: part.mediaType,
+            sizeBytes: part.sizeBytes,
+            integrityId: part.integrityId,
+            ...(part.expiresAt === undefined ? {} : { expiresAt: part.expiresAt }),
+        };
+        const response = await connection.client.replyArtifact(this.conversationIdForThread(thread.id), attachment, signal);
+        return { part, response };
+    }
+    async mcpAppResource(threadId, messageId, partId, expires, token, signal) {
+        const { thread, part } = this.authorizeReplyPart(threadId, messageId, partId, "mcp_app", expires, token);
+        const connection = this.connections.get(thread.sourceId);
+        if (connection === undefined || connection.info.mcpApps?.bridgeVersion !== 1) {
+            throw new WebConsoleError("mcp_app_unavailable", "The MCP App source is offline or incompatible.", 409);
+        }
+        const resource = await connection.client.mcpAppResource(this.conversationIdForThread(thread.id), part.invocationId, part.connectionId, signal);
+        if (resource.app.invocationId !== part.invocationId
+            || resource.app.connectionId !== part.connectionId
+            || resource.app.resourceUri !== part.resourceUri
+            || resource.app.protocolVersion !== part.protocolVersion) {
+            throw new WebConsoleError("mcp_app_identity_mismatch", "The MCP App identity changed after publication.", 409);
+        }
+        return resource;
+    }
+    async mcpAppRequest(threadId, messageId, partId, expires, token, input, signal) {
+        const { thread, part } = this.authorizeReplyPart(threadId, messageId, partId, "mcp_app", expires, token);
+        const confirmationRequired = input.method === "tools/call"
+            || input.method === "ui/open-link"
+            || input.method === "ui/update-model-context";
+        if (confirmationRequired && input.confirmed !== true) {
+            throw new WebConsoleError("mcp_app_confirmation_required", "Confirm this MCP App action before continuing.", 409);
+        }
+        const connection = this.connections.get(thread.sourceId);
+        if (connection === undefined || connection.info.mcpApps?.bridgeVersion !== 1) {
+            throw new WebConsoleError("mcp_app_unavailable", "The MCP App source is offline or incompatible.", 409);
+        }
+        return await connection.client.mcpAppRequest(this.conversationIdForThread(thread.id), {
+            invocationId: part.invocationId,
+            connectionId: part.connectionId,
+            method: input.method,
+            ...(input.params === undefined ? {} : { params: input.params }),
+            ...(input.confirmed === undefined ? {} : { confirmed: input.confirmed }),
+        }, signal);
     }
     async registerWebPushSubscription(input) {
         if (input.previousSubscriptionId !== undefined && input.previousEndpoint !== undefined) {
@@ -185,17 +260,29 @@ export class WebService {
         const thread = this.store.getThread(threadId);
         if (thread === undefined)
             throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        threadId = thread.id;
         const connection = this.connections.get(thread.sourceId);
         if (connection === undefined)
             throw new WebConsoleError("agent_offline", "This agent is offline.", 409);
         if (!connection.info.supportsAskUser)
             return undefined;
-        const snapshot = await connection.client.pendingAsk(`web:${threadId}`, AbortSignal.timeout(INFO_TIMEOUT_MS));
+        const snapshot = await connection.client.pendingAsk(this.store.cronConversationIdForThread(thread.id) ?? `web:${thread.id}`, AbortSignal.timeout(INFO_TIMEOUT_MS));
         if (!this.stopped && snapshot !== undefined && isFuturePendingAsk(snapshot, this.currentDate())) {
-            this.enqueueAskPush(threadId, snapshot);
+            this.enqueueAskPush(thread.id, snapshot);
         }
         return snapshot;
     }
+    async ask(threadId, interactionId) {
+        const thread = this.store.getThread(threadId);
+        if (thread === undefined)
+            throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        const connection = this.connections.get(thread.sourceId);
+        if (connection === undefined)
+            throw new WebConsoleError("agent_offline", "This agent is offline.", 409);
+        if (!connection.info.supportsAskById)
+            return undefined;
+        return await connection.client.ask(interactionId, AbortSignal.timeout(INFO_TIMEOUT_MS));
+    }
     async submitAsk(threadId, interactionId, answers) {
         const thread = this.store.getThread(threadId);
         if (thread === undefined)
@@ -204,30 +291,34 @@ export class WebService {
         if (connection === undefined || !connection.info.supportsAskUser) {
             throw new WebConsoleError("ask_user_unavailable", "This agent does not support interactive questions.", 409);
         }
-        const result = await connection.client.submitAsk(`web:${threadId}`, interactionId, answers);
+        const conversationId = this.store.cronConversationIdForThread(thread.id) ?? `web:${thread.id}`;
+        const result = await connection.client.submitAsk(conversationId, interactionId, answers);
         if (result.accepted)
             this.store.staleWebPushEvent(`ask:${interactionId}`, "answered");
         return result;
     }
     patchThread(id, patch) {
         const thread = this.store.patchThread(id, patch);
-        this.emit("thread.changed", id, { thread });
-        this.emit("threads.changed", id);
+        this.emit("thread.changed", thread.id, { thread });
+        this.emit("threads.changed", thread.id);
         return thread;
     }
     async deleteThread(id) {
-        if (this.activeTurns.has(id)) {
+        const resolved = this.store.getThread(id)?.id;
+        if (resolved === undefined)
+            throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        if (this.activeTurns.has(resolved)) {
             throw new WebConsoleError("turn_active", "Cancel the active turn before deleting this conversation.", 409);
         }
-        const result = await this.store.deleteArchivedThread(id);
+        const result = await this.store.deleteArchivedThread(resolved);
         if (result.orphanedFiles > 0) {
             this.options.logger?.warn?.("Deleted a web conversation with attachment files deferred to orphan cleanup.", {
-                threadId: id,
+                threadId: resolved,
                 count: result.orphanedFiles,
             });
         }
-        this.emit("thread.changed", id, { threadId: id, removed: true });
-        this.emit("threads.changed", id);
+        this.emit("thread.changed", resolved, { threadId: resolved, removed: true });
+        this.emit("threads.changed", resolved);
     }
     patchAgent(sourceId, patch) {
         const agent = this.store.setAgentPinned(sourceId, patch.pinned);
@@ -244,12 +335,126 @@ export class WebService {
         }
         return connection.info.skills ?? { status: "unsupported", items: [] };
     }
+    async cronOverview(sourceId) {
+        const agent = this.store.getAgent(sourceId);
+        if (agent === undefined)
+            throw new WebConsoleError("agent_not_found", "Agent not found.", 404);
+        const connection = this.connections.get(sourceId);
+        if (connection?.info.cron?.read === true) {
+            const overview = await connection.client.cronOverview(AbortSignal.timeout(INFO_TIMEOUT_MS));
+            const synced = this.store.syncCronOverviewResult({ sourceId, ...overview });
+            if (synced.changed) {
+                this.emit("cron.changed", undefined, { sourceId });
+                this.emit("threads.changed");
+            }
+            return synced.overview;
+        }
+        const stored = this.store.storedCronOverview(sourceId);
+        if (stored !== undefined)
+            return { ...stored, actionsEnabled: false };
+        throw new WebConsoleError("cron_unavailable", "This agent does not expose first-class cron operator state.", 404);
+    }
+    async cronRuns(sourceId, jobId, input) {
+        const agent = this.store.getAgent(sourceId);
+        if (agent === undefined)
+            throw new WebConsoleError("agent_not_found", "Agent not found.", 404);
+        const connection = this.connections.get(sourceId);
+        if (connection?.info.cron?.read !== true) {
+            if (this.store.cronThread(sourceId, jobId) === undefined) {
+                throw new WebConsoleError("cron_job_not_found", "Cron job not found for this agent.", 404);
+            }
+            if (input.before !== undefined)
+                return { runs: [] };
+            const stored = this.store.storedCronRuns(sourceId, jobId, input.limit);
+            return stored.messages === undefined
+                ? stored
+                : { ...stored, messages: stored.messages.map((message) => this.decorateMessage(message)) };
+        }
+        const page = await connection.client.cronRuns(jobId, {
+            limit: input.limit,
+            ...(input.before === undefined ? {} : { before: input.before }),
+            signal: AbortSignal.timeout(INFO_TIMEOUT_MS),
+        });
+        const reconciled = this.store.reconcileCronRunsResult(sourceId, jobId, page.runs);
+        if (reconciled.changed) {
+            const threadId = this.store.cronThread(sourceId, jobId)?.id;
+            this.emit("thread.changed", threadId);
+            this.emit("threads.changed", threadId);
+        }
+        return { ...page, messages: reconciled.messages.map((message) => this.decorateMessage(message)) };
+    }
+    async cronRun(sourceId, jobId, runId) {
+        const connection = this.requireCronConnection(sourceId, false);
+        const run = await connection.client.cronRun(jobId, runId, AbortSignal.timeout(INFO_TIMEOUT_MS));
+        const reconciled = this.store.reconcileCronRunsResult(sourceId, jobId, [run]);
+        const message = reconciled.messages[0];
+        if (message === undefined) {
+            throw new WebConsoleError("invalid_operator_cron", "Cron detail did not reconcile a message.", 502);
+        }
+        if (reconciled.changed) {
+            this.emit("thread.changed", message.threadId, { messageId: message.id });
+            this.emit("threads.changed", message.threadId);
+        }
+        return this.decorateMessage(message);
+    }
+    async cronConfigView(sourceId) {
+        const connection = this.requireCronConnection(sourceId, false);
+        return await connection.client.cronConfigView(AbortSignal.timeout(INFO_TIMEOUT_MS));
+    }
+    async cronRunNow(sourceId, jobId, input) {
+        const connection = this.requireCronConnection(sourceId, true);
+        const result = await connection.client.cronRunNow(jobId, input, AbortSignal.timeout(INFO_TIMEOUT_MS));
+        if (result.kind === "completed") {
+            const reconciled = this.store.reconcileCronRunsResult(sourceId, jobId, [result.value.run]);
+            if (reconciled.changed) {
+                const threadId = this.store.cronThread(sourceId, jobId)?.id;
+                this.emit("thread.changed", threadId);
+                this.emit("threads.changed", threadId);
+            }
+        }
+        return result;
+    }
+    async cronSetEffectiveEnabled(sourceId, jobId, enabled, input) {
+        const connection = this.requireCronConnection(sourceId, true);
+        const result = await connection.client.cronSetEffectiveEnabled(jobId, enabled, input, AbortSignal.timeout(INFO_TIMEOUT_MS));
+        if (result.kind === "confirmation_required")
+            return result;
+        const refreshed = await connection.client.cronOverview(AbortSignal.timeout(INFO_TIMEOUT_MS));
+        const synced = this.store.syncCronOverviewResult({ sourceId, ...refreshed });
+        const overview = synced.overview;
+        const job = overview.jobs.find((candidate) => candidate.jobId === jobId);
+        if (job === undefined)
+            throw new WebConsoleError("invalid_operator_cron", "Updated cron job disappeared.", 502);
+        if (synced.changed) {
+            this.emit("cron.changed", job.threadId, { sourceId, jobId });
+            this.emit("thread.changed", job.threadId, { thread: this.store.getThread(job.threadId) });
+            this.emit("threads.changed", job.threadId);
+        }
+        return { ...result, value: { job } };
+    }
     async deliverNotification(input) {
         if (this.stopped) {
             throw new WebConsoleError("web_service_stopping", "The web service is stopping.", 409);
         }
         if (this.store.getAgent(input.sourceId) === undefined)
             await this.refreshAgents();
+        if (input.triggerKind === "job") {
+            const completed = this.store.upsertProcessJobCard({
+                sourceId: input.sourceId,
+                threadId: input.threadId,
+                deliveryKey: input.deliveryKey,
+                processJob: input.processJob,
+                ...(input.text === undefined ? {} : { responseText: input.text }),
+                ...(input.parts === undefined ? {} : { replyParts: input.parts }),
+            });
+            const message = this.store.getThreadDetail(input.threadId)?.messages.find((candidate) => candidate.parts.some((part) => part.type === "process-job" && part.job.jobId === input.processJob.jobId));
+            if (!completed.duplicate && message !== undefined) {
+                this.emit("message.changed", input.threadId, { messageId: message.id, updatedAt: message.updatedAt });
+            }
+            this.emit("threads.changed", input.threadId, { thread: completed.thread });
+            this.emit("thread.changed", input.threadId, { thread: completed.thread });
+            return completed;
+        }
         const reservation = this.store.reserveNotification(input);
         if (reservation.duplicate)
             return this.store.completeNotification(reservation);
@@ -263,6 +468,26 @@ export class WebService {
         this.activeNotifications.set(activeKey, delivery);
         return delivery;
     }
+    /** Proxy one authenticated retained card to its exact agent/thread owner. */
+    async threadJob(threadId, jobId) {
+        const thread = this.store.getThread(threadId);
+        if (thread === undefined)
+            throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        if (!this.store.processJobCardBelongsToThread(thread.sourceId, threadId, jobId)) {
+            throw new WebConsoleError("process_job_not_found", "Process job was not found for this conversation.", 404);
+        }
+        const connection = this.connections.get(thread.sourceId);
+        if (connection === undefined || connection.info.supportsJobs !== true) {
+            throw new WebConsoleError("process_jobs_unavailable", "Process jobs are unavailable for this agent.", 409);
+        }
+        const job = await connection.client.getJob(jobId, AbortSignal.timeout(INFO_TIMEOUT_MS));
+        if (job.jobId !== jobId
+            || job.origin.channel !== "web"
+            || job.origin.conversationId.split("#", 1)[0] !== `web:${threadId}`) {
+            throw new WebConsoleError("process_job_not_found", "Process job was not found for this conversation.", 404);
+        }
+        return job;
+    }
     async startTurn(threadId, input) {
         const text = input.text ?? "";
         const operatorText = input.quote === undefined ? text : formatQuotedTurn(input.quote.text, text);
@@ -273,8 +498,11 @@ export class WebService {
         const thread = this.store.getThread(threadId);
         if (thread === undefined)
             throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        threadId = thread.id;
         const agent = this.store.getAgent(thread.sourceId);
         const connection = this.connections.get(thread.sourceId);
+        if (thread.trigger?.kind === "cron")
+            throw cronChannelReadOnlyError();
         if (agent === undefined || connection === undefined || !thread.canSend) {
             throw new WebConsoleError("agent_offline", "This agent is offline. The conversation remains available read-only.", 409);
         }
@@ -292,6 +520,7 @@ export class WebService {
         const thread = this.store.getThread(threadId);
         if (thread === undefined)
             throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        threadId = thread.id;
         const connection = this.connections.get(thread.sourceId);
         const active = this.activeTurns.get(threadId);
         const reserved = this.store.reserveLiveInput(threadId, text);
@@ -316,10 +545,15 @@ export class WebService {
         return { message: reserved.message, disposition: "pending" };
     }
     async cancelTurn(threadId) {
+        const resolved = this.store.getThread(threadId)?.id;
+        if (resolved === undefined)
+            throw new WebConsoleError("thread_not_found", "Conversation not found.", 404);
+        threadId = resolved;
         const active = this.activeTurns.get(threadId);
         const stored = this.store.activeTurn(threadId);
         if (stored === undefined)
             throw new WebConsoleError("no_active_turn", "This conversation has no active turn.", 409);
+        const reason = createChannelUserCancelReason("Web");
         const liveInputs = [...this.activeLiveInputs.entries()]
             .filter(([, input]) => input.threadId === threadId);
         const cancelledInputs = this.store.cancelLiveInputs(threadId);
@@ -327,13 +561,13 @@ export class WebService {
             this.emit("message.changed", threadId, { messageId: message.id, updatedAt: message.updatedAt });
         }
         for (const [, input] of liveInputs) {
-            input.controller.abort(new WebTurnCancellation("user", "Live input cancelled from the web console."));
+            input.controller.abort(reason);
         }
         if (active !== undefined) {
-            void active.client.cancel(stored.conversationId).catch((error) => {
+            await active.client.cancel(stored.conversationId).catch((error) => {
                 this.options.logger?.debug?.("Web turn cancel request failed.", { error: errorMessage(error) });
             });
-            active.controller.abort(new WebTurnCancellation("user", "Cancelled from the web console."));
+            active.controller.abort(reason);
         }
         const thread = this.store.getThread(threadId);
         if (thread === undefined)
@@ -506,7 +740,7 @@ export class WebService {
                 },
             });
             await coalescer.flush();
-            const detail = this.store.completeTurn(started.turnId, response.finalText, response.metadata);
+            const detail = this.store.completeTurn(started.turnId, response.finalText, response.metadata, response.parts);
             this.emit("turn.changed", started.thread.id, { turn: detail.thread.runState });
             this.emit("thread.changed", started.thread.id, { revision: detail.thread.revision });
             this.emit("threads.changed", started.thread.id);
@@ -520,7 +754,8 @@ export class WebService {
             catch (flushError) {
                 failure = flushError;
             }
-            const cancelled = controller.signal.reason instanceof WebTurnCancellation
+            const cancelled = isChannelUserCancelReason(controller.signal.reason)
+                || controller.signal.reason instanceof WebTurnCancellation
                 || error.cancelled === true;
             const code = errorCode(failure);
             const detail = this.store.failTurn(started.turnId, {
@@ -624,12 +859,18 @@ export class WebService {
         if (!connection.info.supportsHistoryAppend) {
             throw new WebConsoleError("history_record_unavailable", "The notification agent does not support durable history append.", 409);
         }
-        await connection.client.recordVerbatim(`web:${reservation.threadId}`, reservation.text, reservation.deliveryKey);
+        await connection.client.recordVerbatim(this.store.notificationConversationId(reservation), reservation.text, reservation.deliveryKey);
         const completed = this.store.completeNotification(reservation);
+        if (completed.thread === undefined) {
+            if (completed.tombstoned === true)
+                return completed;
+            throw new WebConsoleError("storage_corrupt", "A new notification completed without a conversation.", 500);
+        }
         this.emit("threads.changed", completed.thread.id, { thread: completed.thread });
         this.emit("thread.changed", completed.thread.id, { thread: completed.thread });
-        if (!completed.duplicate)
-            this.announcePushEvent(`web-new:${reservation.threadId}`);
+        if (!completed.duplicate) {
+            this.announcePushEvent(notificationPushLogicalKey(reservation.sourceId, reservation.deliveryKey));
+        }
         return completed;
     }
     async toAgentAttachment(attachment) {
@@ -657,9 +898,10 @@ export class WebService {
         }
         catch (error) {
             this.options.logger?.warn?.("Web agent discovery failed.", { error: errorMessage(error) });
-            this.store.replaceAgents([]);
+            const changed = this.store.replaceAgents([]);
             this.connections = new Map();
-            this.emit("agents.changed");
+            if (changed)
+                this.emit("agents.changed", undefined, { agents: this.store.listAgents() });
             return;
         }
         const nextConnections = new Map();
@@ -669,6 +911,7 @@ export class WebService {
             const client = new OperatorClient({
                 baseUrl: agent.baseUrl,
                 ...(agent.apiKey === undefined ? {} : { apiKey: agent.apiKey }),
+                ...(agent.processJobsBearer === undefined ? {} : { processJobsBearer: agent.processJobsBearer }),
                 ...(this.options.fetchImpl === undefined ? {} : { fetchImpl: this.options.fetchImpl }),
             });
             try {
@@ -687,6 +930,8 @@ export class WebService {
                     ...(info.effort === undefined ? {} : { defaultEffort: info.effort }),
                     ...(efforts.length === 0 ? {} : { efforts }),
                     ...(info.modelOptions === undefined ? {} : { modelOptions: info.modelOptions }),
+                    ...(info.cron === undefined ? {} : { cron: info.cron }),
+                    ...(info.supportsAskById ? { supportsAskById: true } : {}),
                     updatedAt: agent.source.updatedAt,
                 };
             }
@@ -699,9 +944,30 @@ export class WebService {
             }
         }));
         this.connections = nextConnections;
-        this.store.replaceAgents(summaries);
-        this.emit("agents.changed", undefined, { agents: this.store.listAgents() });
-        this.emit("threads.changed");
+        const agentsChanged = this.store.replaceAgents(summaries);
+        const cronChangedSources = new Set();
+        await Promise.all([...nextConnections.entries()].map(async ([sourceId, connection]) => {
+            if (connection.info.cron?.read !== true)
+                return;
+            try {
+                const overview = await connection.client.cronOverview(AbortSignal.any([signal, AbortSignal.timeout(INFO_TIMEOUT_MS)]));
+                const synced = this.store.syncCronOverviewResult({ sourceId, ...overview });
+                if (synced.changed)
+                    cronChangedSources.add(sourceId);
+            }
+            catch (error) {
+                this.options.logger?.debug?.("Cron operator refresh failed; retaining the last authoritative snapshot.", {
+                    sourceId,
+                    error: errorMessage(error),
+                });
+            }
+        }));
+        if (agentsChanged)
+            this.emit("agents.changed", undefined, { agents: this.store.listAgents() });
+        for (const sourceId of cronChangedSources)
+            this.emit("cron.changed", undefined, { sourceId });
+        if (cronChangedSources.size > 0)
+            this.emit("threads.changed");
         for (const threadId of this.store.queuedLiveInputThreadIds()) {
             void this.drainQueuedLiveInputs(threadId);
         }
@@ -794,7 +1060,7 @@ export class WebService {
             const connection = thread === undefined ? undefined : this.connections.get(thread.sourceId);
             if (connection !== undefined && connection.info.supportsAskUser) {
                 try {
-                    const snapshot = await connection.client.pendingAsk(`web:${threadId}`, AbortSignal.any([signal, AbortSignal.timeout(INFO_TIMEOUT_MS)]));
+                    const snapshot = await connection.client.pendingAsk(this.store.cronConversationIdForThread(threadId) ?? `web:${threadId}`, AbortSignal.any([signal, AbortSignal.timeout(INFO_TIMEOUT_MS)]));
                     if (snapshot !== undefined) {
                         if (isFuturePendingAsk(snapshot, this.currentDate())) {
                             if (this.stopped || signal.aborted)
@@ -848,7 +1114,10 @@ export class WebService {
         if (connection === undefined || !connection.info.supportsAskUser)
             return "unknown";
         try {
-            const snapshot = await connection.client.pendingAsk(`web:${event.threadId}`, AbortSignal.any([signal, AbortSignal.timeout(INFO_TIMEOUT_MS)]));
+            const boundedSignal = AbortSignal.any([signal, AbortSignal.timeout(INFO_TIMEOUT_MS)]);
+            const snapshot = connection.info.supportsAskById
+                ? await connection.client.ask(interactionId, boundedSignal)
+                : await connection.client.pendingAsk(this.store.cronConversationIdForThread(event.threadId) ?? `web:${event.threadId}`, boundedSignal);
             return snapshot?.interactionId === interactionId
                 && snapshot.status === "pending"
                 && new Date(snapshot.expiresAt).getTime() > this.currentDate().getTime()
@@ -859,6 +1128,108 @@ export class WebService {
             return "unknown";
         }
     }
+    requireCronConnection(sourceId, actions) {
+        if (this.store.getAgent(sourceId) === undefined) {
+            throw new WebConsoleError("agent_not_found", "Agent not found.", 404);
+        }
+        const connection = this.connections.get(sourceId);
+        if (connection === undefined || connection.info.cron?.read !== true) {
+            throw new WebConsoleError("cron_unavailable", "Cron operator state is unavailable for this agent.", 409);
+        }
+        if (actions && connection.info.cron.actions !== true) {
+            throw new WebConsoleError("cron_actions_disabled", "Cron actions require this agent's authenticated operator capability.", 403);
+        }
+        return connection;
+    }
+    authorizeReplyPart(threadId, messageId, partId, type, expires, token) {
+        const access = this.replyAccessTokenStatus(threadId, messageId, type, partId, expires, token);
+        if (access === "invalid") {
+            throw new WebConsoleError("reply_part_not_found", "The reply part is unavailable.", 404);
+        }
+        const { thread, part } = this.requireReplyPart(threadId, messageId, partId, type);
+        this.assertReplyPartRetained(part);
+        if (access === "expired") {
+            throw new WebConsoleError("reply_access_expired", "Reply access expired. Refresh this reply part and try again.", 410);
+        }
+        return { thread, part };
+    }
+    requireReplyPart(threadId, messageId, partId, type) {
+        const thread = this.store.getThread(threadId);
+        const message = this.store.getMessage(messageId);
+        if (thread === undefined || message === undefined || message.threadId !== thread.id) {
+            throw new WebConsoleError("reply_part_not_found", "The reply part is unavailable.", 404);
+        }
+        const matches = message.parts.filter((part) => part.type === type && part.id === partId);
+        if (matches.length !== 1) {
+            throw new WebConsoleError("reply_part_not_found", "The reply part is unavailable.", 404);
+        }
+        const part = matches[0];
+        return { thread, message, part };
+    }
+    assertReplyPartRetained(part) {
+        const expiresAt = part.expiresAt;
+        if (expiresAt !== undefined && Date.parse(expiresAt) <= this.currentDate().getTime()) {
+            throw new WebConsoleError("reply_part_expired", "The reply part has expired.", 410);
+        }
+    }
+    decorateThreadDetail(detail) {
+        return { ...detail, messages: detail.messages.map((message) => this.decorateMessage(message)) };
+    }
+    decorateMessage(message) {
+        const parts = message.parts.map((part) => {
+            if (part.type !== "attachment" && part.type !== "mcp_app")
+                return part;
+            return this.decorateReplyPart(message, part);
+        });
+        return { ...message, parts };
+    }
+    decorateReplyPart(message, part) {
+        const now = this.currentDate().getTime();
+        const retentionDeadline = part.expiresAt === undefined
+            ? Number.POSITIVE_INFINITY
+            : Date.parse(part.expiresAt);
+        const expiresAt = Math.min(now + REPLY_ACCESS_TTL_MS, retentionDeadline);
+        if (!Number.isFinite(expiresAt) || expiresAt <= now)
+            return part;
+        const expires = String(Math.floor(expiresAt / 1_000));
+        const token = this.replyAccessToken(message.threadId, message.id, part.type, part.id, expires);
+        const base = `/api/v1/threads/${encodeURIComponent(message.threadId)}`
+            + `/messages/${encodeURIComponent(message.id)}`;
+        const query = new URLSearchParams({ expires, token }).toString();
+        return part.type === "attachment"
+            ? {
+                ...part,
+                contentUrl: `${base}/reply-attachments/${encodeURIComponent(part.id)}/content?${query}`,
+            }
+            : {
+                ...part,
+                resourceUrl: `${base}/mcp-apps/${encodeURIComponent(part.id)}?${query}`,
+                bridgeUrl: `${base}/mcp-apps/${encodeURIComponent(part.id)}/requests?${query}`,
+            };
+    }
+    replyAccessToken(threadId, messageId, type, partId, expires) {
+        return createHmac("sha256", this.replyAccessKey)
+            .update(["v1", threadId, messageId, type, partId, expires].join("\0"))
+            .digest("base64url");
+    }
+    replyAccessTokenStatus(threadId, messageId, type, partId, expires, supplied) {
+        if (!/^\d{10,13}$/u.test(expires) || !/^[A-Za-z0-9_-]{43}$/u.test(supplied))
+            return "invalid";
+        const expiresMs = Number(expires) * 1_000;
+        if (!Number.isSafeInteger(expiresMs))
+            return "invalid";
+        const expected = Buffer.from(this.replyAccessToken(threadId, messageId, type, partId, expires), "utf8");
+        const candidate = Buffer.from(supplied, "utf8");
+        if (candidate.byteLength !== expected.byteLength || !timingSafeEqual(candidate, expected))
+            return "invalid";
+        const now = this.currentDate().getTime();
+        if (expiresMs > now + REPLY_ACCESS_TTL_MS + 1_000)
+            return "invalid";
+        return expiresMs <= now ? "expired" : "valid";
+    }
+    conversationIdForThread(threadId) {
+        return this.store.cronConversationIdForThread(threadId) ?? `web:${threadId}`;
+    }
     currentDate() {
         return this.options.clock?.() ?? new Date();
     }