@mono-agent/operator-adapter 0.20.11 → 0.21.0

package/dist/tui/server.js

@@ -1,14 +1,42 @@
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { isAbsolute } from "node:path";
-import { AGENT_LIVE_INPUT_MAX_CHARACTERS, DEFAULT_AGENT_ATTACHMENT_MAX_BYTES, DEFAULT_AGENT_ATTACHMENT_MIME_ALLOWLIST, MCP_APP_RESOURCE_MIME_TYPE, MCP_APP_SUPPORTED_VERSIONS, MAX_AGENT_REPLY_PARTS, BoundedHttpResponseWriter, agentAttachmentKindFromMimeType, closeServerBounded, createChannelUserCancelReason, decodeAgentAttachmentText, isAgentResponseCancelledError, parseProcessJobProjection, parseProcessJobProjections, serializeAgentStreamFrame, } from "@mono-agent/agent-contracts";
-import { assertSafeBind, bearerTokensEqual, hostForUrl, isLoopbackHost, listen, normalizeOptionalString, parseCronOperatorOverview, parseCronOperatorRunDetail, parseCronOperatorRunPage, readAuthorizationBearer, } from "@mono-agent/agent-contracts";
+import { AGENT_LIVE_INPUT_MAX_CHARACTERS, AGENT_CONTEXT_IMPORT_MAX_CONVERSATION_ID_BYTES, AGENT_CONTEXT_IMPORT_MAX_IDEMPOTENCY_KEY_BYTES, AGENT_CONTEXT_IMPORT_MAX_TEXT_BYTES, AGENT_CONTEXT_IMPORT_VERSION, DEFAULT_AGENT_ATTACHMENT_MAX_BYTES, DEFAULT_AGENT_ATTACHMENT_MIME_ALLOWLIST, MCP_APP_RESOURCE_MIME_TYPE, MCP_APP_SUPPORTED_VERSIONS, MAX_AGENT_REPLY_PARTS, MAX_PROVIDER_AUTH_BODY_BYTES, ProviderAuthOperationError, BoundedHttpResponseWriter, agentAttachmentKindFromMimeType, closeServerBounded, createChannelUserCancelReason, decodeAgentAttachmentText, isAgentResponseCancelledError, parseMonitorProjection, parseMonitorProjections, parseProcessJobProjection, parseProcessJobProjections, parseProviderAuthSessionInput, parseProviderAuthSessionSnapshot, parseProviderAuthSessionStartInput, parseProviderAuthCheckSessionSnapshot, parseProviderAuthCheckStartInput, parseProviderAuthStatusSnapshot, serializeAgentStreamFrame, } from "@mono-agent/agent-contracts";
+import { assertSafeBind, bearerTokensEqual, hostForUrl, isLoopbackHost, listen, MAX_INFO_BODY_BYTES, normalizeOptionalString, parseCronOperatorOverview, parseCronOperatorRunDetail, parseCronOperatorRunPage, readAuthorizationBearer, } from "@mono-agent/agent-contracts";
 import express, {} from "express";
+const TARGET_WAITER_TIMEOUT_MS = 10 * 60 * 1_000;
+const MAX_TARGET_WAITERS_PER_OPERATION = 100;
+const MAX_TARGET_WAITERS_GLOBAL = 1_000;
+function liveInputTargetKey(conversationId, turnId) {
+    return `${conversationId.length}:${conversationId}${turnId}`;
+}
+function settleLiveInputOffer(res, offer) {
+    if (offer.status === "unavailable") {
+        res.status(200).json(offer);
+        return;
+    }
+    void offer.settled.then((settlement) => {
+        if (!res.writableEnded)
+            res.status(200).json(settlement);
+    }).catch(() => {
+        if (!res.writableEnded)
+            res.status(200).json({ status: "uncertain", reason: "delivery_uncertain" });
+    });
+}
 import { DEFAULT_BASE_PATH, DEFAULT_HOST, DEFAULT_PORT, MAX_FRAME_BYTES, TUI_WIRE_SCHEMA } from "./constants.js";
 import { CronOperatorError, MAX_CRON_OPERATOR_RESPONSE_BYTES, MAX_CRON_OPERATOR_RUN_PAGE, } from "./cron.js";
 import { TuiAdapterError } from "./errors.js";
 const MAX_TURN_BODY_BYTES = 96 * 1024 * 1024;
+const MAX_MODEL_CATALOG_PAGE_SIZE = 200;
+const DEFAULT_MODEL_CATALOG_PAGE_SIZE = 100;
+const MAX_MODEL_CATALOG_RESPONSE_BYTES = 1024 * 1024;
+const MAX_MODEL_CATALOG_PROVIDER_BYTES = 256;
+const MAX_MODEL_CATALOG_QUERY_BYTES = 512;
+const MAX_MODEL_CATALOG_CURSOR_BYTES = 4 * 1024;
 const MAX_VERBATIM_BODY_BYTES = 2 * 1024 * 1024;
+// `{"idempotencyKey":"","text":""}` is 31 bytes. Each legal decoded
+// text/key byte can require a six-byte JSON escape; 31 + 6*(32768+512).
+const MAX_CONTEXT_IMPORT_BODY_BYTES = 199_711;
 const MAX_VERBATIM_TEXT_CHARACTERS = 200_000;
 const MAX_VERBATIM_TEXT_BYTES = 1024 * 1024;
 const MAX_LIVE_INPUT_BODY_BYTES = 32 * 1024;
@@ -38,6 +66,10 @@ export async function startTuiAdapter(options) {
     if ((options.processJobs === undefined) !== (processJobsBearer === undefined)) {
         throw new TuiAdapterError("invalid_config", "processJobs and processJobsBearer must be configured together.");
     }
+    const monitorsBearer = normalizeOptionalString(options.monitorsBearer);
+    if ((options.monitors === undefined) !== (monitorsBearer === undefined)) {
+        throw new TuiAdapterError("invalid_config", "monitors and monitorsBearer must be configured together.");
+    }
     if (options.requestToolEnvironment !== undefined && !isLoopbackHost(host)) {
         throw new TuiAdapterError("unsafe_host", "Request tool environment requires a loopback-only TUI adapter bind.", { host });
     }
@@ -45,12 +77,25 @@ export async function startTuiAdapter(options) {
     const app = express();
     const server = createServer(app);
     const activeTurns = new Set();
+    const liveInputTargets = new Map();
+    let pendingTargetWaiters = 0;
+    const settleTarget = (target, runId) => {
+        target.state = runId === undefined ? "closed" : "ready";
+        if (runId === undefined)
+            delete target.runId;
+        else
+            target.runId = runId;
+        for (const waiter of [...target.waiters])
+            waiter(runId);
+    };
     let stopping = false;
     let stopPromise;
     const infoPath = `${basePath}/v1/info`;
+    const modelsPath = `${basePath}/v1/models`;
     const turnsPath = `${basePath}/v1/turns`;
     const cancelPath = `${basePath}/v1/conversations/:conversationId/cancel`;
     const verbatimPath = `${basePath}/v1/conversations/:conversationId/verbatim`;
+    const contextImportPath = `${basePath}/v1/conversations/:conversationId/context-imports`;
     const liveInputPath = `${basePath}/v1/conversations/:conversationId/live-input`;
     const replyArtifactPath = `${basePath}/v1/conversations/:conversationId/reply-artifacts/:artifactId`;
     const mcpAppPath = `${basePath}/v1/conversations/:conversationId/mcp-apps/:invocationId`;
@@ -66,6 +111,15 @@ export async function startTuiAdapter(options) {
     const jobsPath = `${basePath}/v1/jobs`;
     const jobPath = `${basePath}/v1/jobs/:jobId`;
     const jobCancelPath = `${basePath}/v1/jobs/:jobId/cancel`;
+    const monitorsPath = `${basePath}/v1/monitors`;
+    const monitorPath = `${basePath}/v1/monitors/:monitorId`;
+    const monitorCancelPath = `${basePath}/v1/monitors/:monitorId/cancel`;
+    const providerAuthPath = `${basePath}/v1/provider-auth`;
+    const providerAuthSessionsPath = `${providerAuthPath}/sessions`;
+    const providerAuthSessionPath = `${providerAuthSessionsPath}/:sessionId`;
+    const providerAuthInputPath = `${providerAuthSessionPath}/input`;
+    const providerAuthChecksPath = `${providerAuthPath}/checks`;
+    const providerAuthCheckPath = `${providerAuthChecksPath}/:checkId`;
     app.get(infoPath, (req, res) => {
         if (!authorize(req, res, apiKey)) {
             return;
@@ -86,7 +140,7 @@ export async function startTuiAdapter(options) {
             });
         void Promise.all([resolveInfo(options.info), cronInfo])
             .then(([info, cronState]) => {
-            res.status(200).json({
+            sendBoundedInfo(res, {
                 schema: TUI_WIRE_SCHEMA,
                 pid: process.pid,
                 capabilities: {
@@ -105,7 +159,14 @@ export async function startTuiAdapter(options) {
                         }
                         : {}),
                     ...(typeof options.responder.offerLiveInput === "function" ? { liveInput: true } : {}),
+                    ...(typeof options.responder.offerLiveInput === "function"
+                        && options.responder.liveInputOwnership?.version === 1
+                        ? { liveInputTargeting: { version: 1 } }
+                        : {}),
                     ...(typeof options.responder.deliverVerbatim === "function" ? { historyAppend: true } : {}),
+                    ...(typeof options.responder.importContext === "function"
+                        ? { contextImport: { version: AGENT_CONTEXT_IMPORT_VERSION, maxTextBytes: AGENT_CONTEXT_IMPORT_MAX_TEXT_BYTES } }
+                        : {}),
                     ...(options.interaction === undefined ? {} : { askUser: true }),
                     ...(typeof options.interaction?.getAsk === "function" ? { askById: true } : {}),
                     ...(cronState.kind === "absent"
@@ -122,7 +183,19 @@ export async function startTuiAdapter(options) {
                                 },
                             }),
                     ...(options.processJobs === undefined || processJobsBearer === undefined ? {} : { jobs: true }),
+                    ...(options.monitors === undefined || monitorsBearer === undefined ? {} : { monitors: true }),
                     ...(options.requestToolEnvironment === undefined ? {} : { toolEnvironment: true }),
+                    ...(options.modelCatalog === undefined
+                        ? {}
+                        : { modelCatalog: { version: 1, maxPageSize: MAX_MODEL_CATALOG_PAGE_SIZE } }),
+                    ...(options.providerAuth === undefined
+                        ? {}
+                        : {
+                            providerAuth: {
+                                version: 1,
+                                ...(options.providerAuth.checks === undefined ? {} : { checks: { version: 1 } }),
+                            },
+                        }),
                 },
                 ...(info?.label === undefined ? {} : { label: info.label }),
                 ...(info?.model === undefined ? {} : { model: info.model }),
@@ -132,13 +205,48 @@ export async function startTuiAdapter(options) {
                     ? {}
                     : { modelOptions: info.modelOptions }),
                 ...(info?.skills === undefined ? {} : { skills: info.skills }),
-            });
+                ...(info?.providers === undefined || info.providers.length === 0 ? {} : { providers: info.providers }),
+            }, options.logger);
         })
             .catch((error) => {
             options.logger?.error?.("TUI info provider failed.", { error: errorToMessage(error) });
             sendJsonError(res, 500, error);
         });
     });
+    app.get(modelsPath, (req, res, next) => {
+        if (!authorize(req, res, apiKey))
+            return;
+        if (options.modelCatalog === undefined) {
+            sendJsonError(res, 404, new TuiAdapterError("invalid_request", "The model catalog is unavailable."));
+            return;
+        }
+        let request;
+        try {
+            request = normalizeModelCatalogRequest(req);
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        let page;
+        try {
+            // The catalog is a trust boundary only in the sense that the provider is
+            // host-owned; a throwing supplier must still fail as a server error
+            // rather than silently serving an empty catalog (see the "totality"
+            // contract in the composition layer — that layer never throws).
+            page = options.modelCatalog(request);
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        try {
+            sendBoundedModelCatalog(res, page);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
     app.get(jobsPath, (req, res, next) => {
         if (!authorize(req, res, processJobsBearer))
             return;
@@ -202,12 +310,81 @@ export async function startTuiAdapter(options) {
             }
         });
     });
+    app.get(monitorsPath, (req, res, next) => {
+        if (!authorize(req, res, monitorsBearer))
+            return;
+        if (options.monitors === undefined || monitorsBearer === undefined) {
+            sendJsonError(res, 404, new TuiAdapterError("invalid_request", "Monitors are unavailable."));
+            return;
+        }
+        void options.monitors.list()
+            .then((monitors) => {
+            res.status(200).json({ monitors: parseMonitorProjections(monitors) });
+        })
+            .catch(next);
+    });
+    app.get(monitorPath, (req, res, next) => {
+        if (!authorize(req, res, monitorsBearer))
+            return;
+        if (options.monitors === undefined || monitorsBearer === undefined) {
+            sendJsonError(res, 404, new TuiAdapterError("invalid_request", "Monitors are unavailable."));
+            return;
+        }
+        const monitorId = boundedMonitorId(req.params.monitorId);
+        if (monitorId === undefined) {
+            sendJsonError(res, 400, new TuiAdapterError("invalid_request", "A bounded monitorId is required."));
+            return;
+        }
+        void options.monitors.get(monitorId)
+            .then((monitor) => {
+            if (monitor === undefined) {
+                res.status(404).json({ error: { code: "monitor_not_found", message: "Monitor was not found." } });
+            }
+            else {
+                res.status(200).json(parseMonitorProjection(monitor));
+            }
+        })
+            .catch(next);
+    });
+    app.post(monitorCancelPath, (req, res, next) => {
+        if (!authorize(req, res, monitorsBearer))
+            return;
+        if (options.monitors === undefined || monitorsBearer === undefined) {
+            sendJsonError(res, 404, new TuiAdapterError("invalid_request", "Monitors are unavailable."));
+            return;
+        }
+        const monitorId = boundedMonitorId(req.params.monitorId);
+        if (monitorId === undefined) {
+            sendJsonError(res, 400, new TuiAdapterError("invalid_request", "A bounded monitorId is required."));
+            return;
+        }
+        void options.monitors.cancel(monitorId)
+            .then((monitor) => {
+            res.status(200).json(parseMonitorProjection(monitor));
+        })
+            .catch((error) => {
+            const code = typeof error === "object" && error !== null
+                ? error.code
+                : undefined;
+            if (code === "monitor_not_found") {
+                res.status(404).json({ error: { code, message: errorToMessage(error) } });
+            }
+            else if (code === "monitor_conflict") {
+                res.status(409).json({ error: { code, message: errorToMessage(error) } });
+            }
+            else {
+                next(error);
+            }
+        });
+    });
     // Keep the enlarged parser scoped to turn submission. 64 MiB of decoded
     // files expands to about 85.4 MiB in base64, while info/cancel stay bodyless.
     app.post(turnsPath, express.json({ limit: MAX_TURN_BODY_BYTES }), (req, res) => {
         if (!authorize(req, res, apiKey)) {
             return;
         }
+        if (!authorizeMonitorWake(req, res, req.body?.processJobWakeDeliveryKey, monitorsBearer))
+            return;
         void handleTurn(req, res).catch((error) => {
             options.logger?.error?.("TUI turn failed before response.", { error: errorToMessage(error) });
             if (!res.headersSent) {
@@ -350,6 +527,36 @@ export async function startTuiAdapter(options) {
             res.status(200).json({ recorded: true, conversationId: body.conversationId });
         }).catch(next);
     });
+    app.post(contextImportPath, (_req, res, next) => {
+        res.setHeader("Cache-Control", "private, no-store, max-age=0");
+        next();
+    }, express.json({ limit: MAX_CONTEXT_IMPORT_BODY_BYTES, strict: true }), (req, res, next) => {
+        if (!authorize(req, res, apiKey))
+            return;
+        if (typeof options.responder.importContext !== "function") {
+            sendContextImportError(res, 501, "context_import_unsupported", "This responder does not support canonical context import.", "unsupported");
+            return;
+        }
+        let normalized;
+        try {
+            normalized = normalizeContextImportBody(req.params.conversationId, req.body);
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        void options.responder.importContext(normalized.conversationId, normalized.request).then((result) => {
+            res.setHeader("Cache-Control", "private, no-store, max-age=0");
+            if (result.status === "conflict") {
+                sendContextImportError(res, 409, "context_import_conflict", "Canonical context import conflicts with existing history.", result.reason);
+                return;
+            }
+            res.status(200).json({ imported: true, status: result.status, conversationId: normalized.conversationId });
+        }).catch((error) => {
+            options.logger?.error?.("TUI context import failed.", { error: errorToMessage(error) });
+            sendContextImportError(res, 500, "context_import_failed", "Canonical context import failed.", "operation_failed");
+        });
+    });
     app.post(liveInputPath, express.json({ limit: MAX_LIVE_INPUT_BODY_BYTES, strict: true }), (req, res, next) => {
         if (!authorize(req, res, apiKey))
             return;
@@ -368,14 +575,86 @@ export async function startTuiAdapter(options) {
             || (body.deliveryKey !== undefined
                 && (typeof body.deliveryKey !== "string"
                     || body.deliveryKey.trim().length === 0
-                    || body.deliveryKey.length > 1_024))) {
+                    || body.deliveryKey.length > 1_024))
+            || (body.targetTurnId !== undefined
+                && (typeof body.targetTurnId !== "string" || body.targetTurnId.trim().length === 0 || body.targetTurnId.length > 4_096))
+            || (body.targetRunId !== undefined
+                && (typeof body.targetRunId !== "string" || body.targetRunId.trim().length === 0 || body.targetRunId.length > 4_096))) {
             next(new TuiAdapterError("invalid_request", `Live input requires id, receivedAt, and 1-${String(AGENT_LIVE_INPUT_MAX_CHARACTERS)} text characters.`));
             return;
         }
+        if (!authorizeMonitorWake(req, res, body.deliveryKey, monitorsBearer))
+            return;
         if (typeof options.responder.offerLiveInput !== "function") {
             res.status(200).json({ status: "unavailable", reason: "unsupported" });
             return;
         }
+        const inputId = body.id;
+        const inputText = body.text;
+        const receivedAt = body.receivedAt;
+        const targetTurnId = typeof body.targetTurnId === "string" ? body.targetTurnId : undefined;
+        const explicitRunId = typeof body.targetRunId === "string" ? body.targetRunId : undefined;
+        if (targetTurnId !== undefined) {
+            const target = liveInputTargets.get(liveInputTargetKey(conversationId, targetTurnId));
+            if (target === undefined || target.state === "closed") {
+                res.status(200).json({ status: "unavailable", reason: "inactive" });
+                return;
+            }
+            const offerToTarget = (runId) => {
+                if (res.writableEnded || res.destroyed)
+                    return;
+                if (runId === undefined || (explicitRunId !== undefined && explicitRunId !== runId)) {
+                    res.status(200).json({ status: "unavailable", reason: "inactive" });
+                    return;
+                }
+                try {
+                    settleLiveInputOffer(res, options.responder.offerLiveInput({
+                        conversationId,
+                        id: inputId,
+                        text: inputText,
+                        receivedAt,
+                        targetRunId: runId,
+                        ...(typeof body.deliveryKey === "string" ? { deliveryKey: body.deliveryKey } : {}),
+                    }));
+                }
+                catch (error) {
+                    next(error);
+                }
+            };
+            if (target.state === "ready") {
+                offerToTarget(target.runId);
+                return;
+            }
+            if (target.waiters.size >= MAX_TARGET_WAITERS_PER_OPERATION || pendingTargetWaiters >= MAX_TARGET_WAITERS_GLOBAL) {
+                res.status(200).json({ status: "unavailable", reason: "full" });
+                return;
+            }
+            pendingTargetWaiters += 1;
+            let detached = false;
+            let timer;
+            const abort = () => { detach(); };
+            const settle = (runId) => {
+                detach();
+                offerToTarget(runId);
+            };
+            const detach = () => {
+                if (detached)
+                    return;
+                detached = true;
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                req.off("aborted", abort);
+                res.off("close", abort);
+                target.waiters.delete(settle);
+                pendingTargetWaiters -= 1;
+            };
+            target.waiters.add(settle);
+            timer = setTimeout(() => { settle(undefined); }, TARGET_WAITER_TIMEOUT_MS);
+            timer.unref?.();
+            req.once("aborted", abort);
+            res.once("close", abort);
+            return;
+        }
         let offer;
         try {
             offer = options.responder.offerLiveInput({
@@ -383,6 +662,7 @@ export async function startTuiAdapter(options) {
                 id: body.id,
                 text: body.text,
                 receivedAt: body.receivedAt,
+                ...(explicitRunId === undefined ? {} : { targetRunId: explicitRunId }),
                 ...(typeof body.deliveryKey === "string" ? { deliveryKey: body.deliveryKey } : {}),
             });
         }
@@ -390,13 +670,7 @@ export async function startTuiAdapter(options) {
             next(error);
             return;
         }
-        if (offer.status === "unavailable") {
-            res.status(200).json(offer);
-            return;
-        }
-        void offer.settled.then((settlement) => {
-            res.status(200).json(settlement);
-        }).catch(next);
+        settleLiveInputOffer(res, offer);
     });
     app.get(askPath, (req, res) => {
         if (!authorize(req, res, apiKey))
@@ -552,6 +826,158 @@ export async function startTuiAdapter(options) {
             next(error);
         }
     });
+    const requireProviderAuth = (req, res) => {
+        if (options.providerAuth === undefined) {
+            sendJsonError(res, 404, new TuiAdapterError("invalid_request", "Provider authentication is unavailable."));
+            return undefined;
+        }
+        return authorize(req, res, apiKey) ? options.providerAuth : undefined;
+    };
+    const sendProviderAuth = (res, status, body) => {
+        res.setHeader("Cache-Control", "private, no-store, max-age=0");
+        res.status(status).json(body);
+    };
+    app.use(providerAuthPath, (_req, res, next) => {
+        res.setHeader("Cache-Control", "private, no-store, max-age=0");
+        next();
+    });
+    app.get(providerAuthPath, (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        void providerAuth.status()
+            .then((snapshot) => sendProviderAuth(res, 200, parseProviderAuthStatusSnapshot(snapshot)))
+            .catch(next);
+    });
+    app.post(providerAuthSessionsPath, express.json({ limit: MAX_PROVIDER_AUTH_BODY_BYTES, strict: true }), (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        let input;
+        try {
+            input = parseProviderAuthSessionStartInput(req.body);
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        void providerAuth.start(input)
+            .then((snapshot) => sendProviderAuth(res, 201, parseProviderAuthSessionSnapshot(snapshot)))
+            .catch(next);
+    });
+    app.get(providerAuthSessionPath, (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        const sessionId = boundedProviderAuthSessionId(req.params.sessionId);
+        if (sessionId === undefined) {
+            next(new TuiAdapterError("invalid_request", "A bounded provider auth session id is required."));
+            return;
+        }
+        void providerAuth.get(sessionId).then((snapshot) => {
+            if (snapshot === undefined) {
+                sendJsonError(res, 404, new ProviderAuthOperationError("provider_auth_not_found", "Provider authentication session was not found.", 404));
+            }
+            else {
+                sendProviderAuth(res, 200, parseProviderAuthSessionSnapshot(snapshot));
+            }
+        }).catch(next);
+    });
+    app.post(providerAuthInputPath, express.json({ limit: MAX_PROVIDER_AUTH_BODY_BYTES, strict: true }), (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        const sessionId = boundedProviderAuthSessionId(req.params.sessionId);
+        if (sessionId === undefined) {
+            next(new TuiAdapterError("invalid_request", "A bounded provider auth session id is required."));
+            return;
+        }
+        let input;
+        try {
+            input = parseProviderAuthSessionInput(req.body);
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        void providerAuth.submit(sessionId, input)
+            .then((snapshot) => sendProviderAuth(res, 200, parseProviderAuthSessionSnapshot(snapshot)))
+            .catch(next);
+    });
+    app.delete(providerAuthSessionPath, (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        const sessionId = boundedProviderAuthSessionId(req.params.sessionId);
+        if (sessionId === undefined) {
+            next(new TuiAdapterError("invalid_request", "A bounded provider auth session id is required."));
+            return;
+        }
+        void providerAuth.cancel(sessionId).then(() => {
+            res.setHeader("Cache-Control", "private, no-store, max-age=0");
+            res.status(204).end();
+        }).catch(next);
+    });
+    app.post(providerAuthChecksPath, express.json({ limit: MAX_PROVIDER_AUTH_BODY_BYTES, strict: true }), (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        if (providerAuth.checks === undefined) {
+            next(new ProviderAuthOperationError("provider_auth_unavailable", "Provider checks are unavailable.", 503));
+            return;
+        }
+        let input;
+        try {
+            input = parseProviderAuthCheckStartInput(req.body);
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        void providerAuth.checks.start(input)
+            .then((snapshot) => sendProviderAuth(res, 201, parseProviderAuthCheckSessionSnapshot(snapshot)))
+            .catch(next);
+    });
+    app.get(providerAuthCheckPath, (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        if (providerAuth.checks === undefined) {
+            next(new ProviderAuthOperationError("provider_auth_unavailable", "Provider checks are unavailable.", 503));
+            return;
+        }
+        const checkId = boundedProviderAuthSessionId(req.params.checkId);
+        if (checkId === undefined) {
+            next(new TuiAdapterError("invalid_request", "A bounded provider auth check id is required."));
+            return;
+        }
+        void providerAuth.checks.get(checkId).then((snapshot) => {
+            if (snapshot === undefined) {
+                sendJsonError(res, 404, new ProviderAuthOperationError("provider_auth_not_found", "Provider auth check was not found.", 404));
+            }
+            else {
+                sendProviderAuth(res, 200, parseProviderAuthCheckSessionSnapshot(snapshot));
+            }
+        }).catch(next);
+    });
+    app.delete(providerAuthCheckPath, (req, res, next) => {
+        const providerAuth = requireProviderAuth(req, res);
+        if (providerAuth === undefined)
+            return;
+        if (providerAuth.checks === undefined) {
+            next(new ProviderAuthOperationError("provider_auth_unavailable", "Provider checks are unavailable.", 503));
+            return;
+        }
+        const checkId = boundedProviderAuthSessionId(req.params.checkId);
+        if (checkId === undefined) {
+            next(new TuiAdapterError("invalid_request", "A bounded provider auth check id is required."));
+            return;
+        }
+        void providerAuth.checks.cancel(checkId).then(() => {
+            res.setHeader("Cache-Control", "private, no-store, max-age=0");
+            res.status(204).end();
+        }).catch(next);
+    });
     app.use((error, _req, res, next) => {
         if (res.headersSent) {
             next(error);
@@ -569,6 +995,13 @@ export async function startTuiAdapter(options) {
             sendJsonError(res, error.status, error);
             return;
         }
+        if (error instanceof ProviderAuthOperationError) {
+            if (error.retryAfterSeconds !== undefined) {
+                res.setHeader("Retry-After", String(error.retryAfterSeconds));
+            }
+            sendJsonError(res, error.status, error);
+            return;
+        }
         const isClientError = codeOf(error) === "invalid_request" ||
             (error instanceof SyntaxError && error.status === 400);
         sendJsonError(res, isClientError ? 400 : 500, error);
@@ -600,16 +1033,43 @@ export async function startTuiAdapter(options) {
     const url = `http://${hostForUrl(host)}:${boundPort}`;
     async function handleTurn(req, res) {
         const body = normalizeTurnBody(req.body, options.requestToolEnvironment);
+        const requestId = randomUUID();
+        const web = isRecord(body.metadata.web) ? body.metadata.web : undefined;
+        const webTurnId = body.client === "web" && typeof web?.turnId === "string" && web.turnId.length > 0
+            ? web.turnId
+            : undefined;
+        const targetKey = webTurnId === undefined || options.responder.liveInputOwnership?.version !== 1
+            ? undefined
+            : liveInputTargetKey(body.conversationId, webTurnId);
+        if (targetKey !== undefined && liveInputTargets.has(targetKey)) {
+            throw new TuiAdapterError("invalid_request", "Web turn is already active.");
+        }
         const controller = new AbortController();
         activeTurns.add(controller);
         if (stopping)
             controller.abort(new Error("TUI adapter is stopping."));
-        const requestId = randomUUID();
+        let target;
+        if (targetKey !== undefined) {
+            target = { state: "pending", waiters: new Set() };
+            liveInputTargets.set(targetKey, target);
+        }
         const request = {
             conversationId: body.conversationId,
             text: body.text,
             abortSignal: controller.signal,
             metadata: requestMetadata(body, requestId),
+            ...(target === undefined ? {} : {
+                onLiveInputOwnership: (event) => {
+                    if (target?.state === "closed")
+                        return;
+                    if (event.status === "ready") {
+                        settleTarget(target, event.runId);
+                    }
+                    else {
+                        settleTarget(target, undefined);
+                    }
+                },
+            }),
             ...(body.attachments === undefined || body.attachments.length === 0
                 ? {}
                 : { attachments: body.attachments }),
@@ -646,6 +1106,11 @@ export async function startTuiAdapter(options) {
             }).catch(() => undefined);
         }
         finally {
+            if (target !== undefined) {
+                settleTarget(target, undefined);
+                if (targetKey !== undefined && liveInputTargets.get(targetKey) === target)
+                    liveInputTargets.delete(targetKey);
+            }
             activeTurns.delete(controller);
             res.end();
         }
@@ -660,9 +1125,13 @@ export async function startTuiAdapter(options) {
         stop() {
             stopPromise ??= (async () => {
                 stopping = true;
+                for (const target of liveInputTargets.values()) {
+                    settleTarget(target, undefined);
+                }
+                liveInputTargets.clear();
                 for (const controller of activeTurns)
                     controller.abort(new Error("TUI adapter stopped."));
-                await closeServerBounded(server);
+                await Promise.all([closeServerBounded(server), options.providerAuth?.stop()]);
                 activeTurns.clear();
             })();
             return stopPromise;
@@ -1069,6 +1538,36 @@ function sendMcpAppError(res, error) {
     setPrivateMcpAppHeaders(res);
     sendJsonError(res, status, error);
 }
+function normalizeContextImportBody(rawConversationId, body) {
+    const conversationId = normalizeOptionalString(typeof rawConversationId === "string" ? rawConversationId : undefined);
+    if (conversationId === undefined
+        || Buffer.byteLength(conversationId, "utf8") > AGENT_CONTEXT_IMPORT_MAX_CONVERSATION_ID_BYTES
+        || conversationId.includes("\0")) {
+        throw new TuiAdapterError("invalid_request", "A bounded conversationId is required.");
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        throw new TuiAdapterError("invalid_request", "Request body must be a JSON object.");
+    }
+    const record = body;
+    if (Object.keys(record).sort().join("\0") !== ["idempotencyKey", "text"].join("\0")) {
+        throw new TuiAdapterError("invalid_request", "Request body must contain only text and idempotencyKey.");
+    }
+    if (typeof record.text !== "string"
+        || record.text.trim().length === 0
+        || Buffer.byteLength(record.text, "utf8") > AGENT_CONTEXT_IMPORT_MAX_TEXT_BYTES) {
+        throw new TuiAdapterError("invalid_request", "text must be a string within the context import byte limit.");
+    }
+    if (typeof record.idempotencyKey !== "string"
+        || record.idempotencyKey.trim().length === 0
+        || record.idempotencyKey.includes("\0")
+        || Buffer.byteLength(record.idempotencyKey, "utf8") > AGENT_CONTEXT_IMPORT_MAX_IDEMPOTENCY_KEY_BYTES) {
+        throw new TuiAdapterError("invalid_request", "idempotencyKey must be a bounded non-empty UTF-8 string.");
+    }
+    return {
+        conversationId,
+        request: { text: record.text, idempotencyKey: record.idempotencyKey },
+    };
+}
 function normalizeVerbatimBody(rawConversationId, body) {
     const conversationId = normalizeOptionalString(typeof rawConversationId === "string" ? rawConversationId : undefined);
     if (conversationId === undefined) {
@@ -1371,6 +1870,171 @@ async function resolveInfo(info) {
     }
     return info;
 }
+function normalizeModelCatalogRequest(req) {
+    const rawProvider = typeof req.query.provider === "string" ? req.query.provider : undefined;
+    const provider = normalizeOptionalString(rawProvider);
+    if (provider !== undefined && Buffer.byteLength(provider, "utf8") > MAX_MODEL_CATALOG_PROVIDER_BYTES) {
+        throw new TuiAdapterError("invalid_request", "provider is too large.");
+    }
+    const rawQuery = typeof req.query.q === "string" ? req.query.q : undefined;
+    const query = normalizeOptionalString(rawQuery);
+    if (query !== undefined && Buffer.byteLength(query, "utf8") > MAX_MODEL_CATALOG_QUERY_BYTES) {
+        throw new TuiAdapterError("invalid_request", "q is too large.");
+    }
+    const rawCursor = typeof req.query.cursor === "string" ? req.query.cursor : undefined;
+    const cursor = normalizeOptionalString(rawCursor);
+    if (cursor !== undefined && Buffer.byteLength(cursor, "utf8") > MAX_MODEL_CATALOG_CURSOR_BYTES) {
+        throw new TuiAdapterError("invalid_request", "cursor is too large.");
+    }
+    if (provider === undefined && query === undefined) {
+        throw new TuiAdapterError("invalid_request", "provider or q is required.");
+    }
+    // `TuiModelCatalogRequest` documents the two modes as mutually exclusive and
+    // suppliers honour that by servicing `provider` and ignoring `query`. Sending
+    // both must therefore be a client error, not a silently provider-scoped page
+    // that looks like it answered the search.
+    if (provider !== undefined && query !== undefined) {
+        throw new TuiAdapterError("invalid_request", "provider and q are mutually exclusive.");
+    }
+    const rawLimit = typeof req.query.limit === "string"
+        ? Number(req.query.limit)
+        : DEFAULT_MODEL_CATALOG_PAGE_SIZE;
+    if (!Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > MAX_MODEL_CATALOG_PAGE_SIZE) {
+        throw new TuiAdapterError("invalid_request", `limit must be 1-${String(MAX_MODEL_CATALOG_PAGE_SIZE)}.`);
+    }
+    return {
+        ...(provider === undefined ? {} : { provider }),
+        ...(query === undefined ? {} : { query }),
+        ...(cursor === undefined ? {} : { cursor }),
+        limit: rawLimit,
+    };
+}
+/**
+ * `/v1/info` fields the fence may shed, least load-bearing first. Every one of
+ * them is already optional on the wire — the response literal omits each when
+ * its source is absent — so shedding produces a body that is still valid at
+ * schema 1, which matters because `TUI_WIRE_SCHEMA` is compared with `!==` and
+ * cannot be bumped. `schema`, `pid` and `capabilities` are never sheddable:
+ * they are the liveness and negotiation half of the response.
+ */
+const INFO_SHED_ORDER = [
+    "modelOptions",
+    "models",
+    "providers",
+    "skills",
+    "label",
+    "effort",
+    "model",
+];
+/**
+ * Send `/v1/info` under the byte contract its consumer enforces.
+ *
+ * Every contributor to this body carries its own producer-side budget (see the
+ * budget table in `agent-app`'s `channel-drivers/tui.ts`, and
+ * `MAX_SKILL_REGISTRY_BYTES` for skills) and those budgets sum to 960 KiB. This
+ * is the last-resort fence behind them: without it the ONLY enforcement of the
+ * 1 MiB cap lived in the consumer, so any producer-side miss took the agent
+ * offline instead of degrading it.
+ *
+ * It measures the exact string it sends rather than estimating, and sends that
+ * string rather than re-serializing, so what was measured is what goes on the
+ * wire. Shedding is logged at error level: a body that reaches this fence is a
+ * producer bug, and it must not disappear silently.
+ */
+function sendBoundedInfo(res, body, logger) {
+    const candidate = { ...body };
+    const dropped = [];
+    let serialized = serializeInfoBody(candidate);
+    while (serialized === undefined) {
+        const field = largestSheddableInfoField(candidate);
+        // Each pass removes one field from a finite set, so this terminates.
+        if (field === undefined)
+            break;
+        delete candidate[field];
+        dropped.push(field);
+        serialized = serializeInfoBody(candidate);
+    }
+    if (serialized !== undefined) {
+        if (dropped.length > 0) {
+            logger?.error?.("TUI info body exceeded its wire budget; fields were dropped.", {
+                droppedFields: dropped.join(","),
+            });
+        }
+        res.status(200).type("application/json").send(serialized);
+        return;
+    }
+    // Nothing sheddable is left and the remainder still will not fit (or will not
+    // serialize at all). Fall back to the fixed liveness floor: a schema-1 body
+    // small by construction, which keeps the agent reachable and its capability
+    // negotiation honest rather than answering 500 and reading as offline.
+    logger?.error?.("TUI info body could not be bounded; served the minimal liveness body.", {
+        droppedFields: dropped.join(","),
+    });
+    res.status(200).type("application/json").send(JSON.stringify({
+        schema: TUI_WIRE_SCHEMA,
+        pid: process.pid,
+        capabilities: { attachments: true },
+    }));
+}
+/**
+ * The optional field costing the most bytes right now.
+ *
+ * Shedding the biggest field first means the fence removes what is ACTUALLY
+ * oversized instead of four innocent projections queued ahead of it: a 1.5 MiB
+ * `skills` registry costs the console its skills, not its model picker as well.
+ * Ties break towards the front of `INFO_SHED_ORDER` (least load-bearing first),
+ * so the choice is deterministic. A field whose own value will not serialize
+ * sorts first of all — it is the reason the body cannot be measured at all.
+ */
+function largestSheddableInfoField(body) {
+    let largest;
+    let largestBytes = -1;
+    for (const field of INFO_SHED_ORDER) {
+        if (!(field in body))
+            continue;
+        const bytes = infoFieldBytes(body[field]);
+        if (bytes > largestBytes) {
+            largest = field;
+            largestBytes = bytes;
+        }
+    }
+    return largest;
+}
+/** Serialized size of one field value; `Infinity` when it cannot be serialized at all. */
+function infoFieldBytes(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        return typeof serialized === "string"
+            ? Buffer.byteLength(serialized, "utf8")
+            : Number.POSITIVE_INFINITY;
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+/** Serialize the candidate body, or `undefined` when it does not fit or does not serialize. */
+function serializeInfoBody(body) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(body);
+    }
+    catch {
+        return undefined;
+    }
+    // `JSON.stringify` yields undefined for a non-serializable top-level value.
+    if (typeof serialized !== "string")
+        return undefined;
+    return Buffer.byteLength(serialized, "utf8") > MAX_INFO_BODY_BYTES ? undefined : serialized;
+}
+function sendBoundedModelCatalog(res, page) {
+    const body = JSON.stringify(page);
+    if (Buffer.byteLength(body, "utf8") > MAX_MODEL_CATALOG_RESPONSE_BYTES) {
+        // The supplier is expected to pre-bound pages; hitting this fence is a
+        // producer bug, not a client mistake, so it reads as a 500.
+        throw new TuiAdapterError("model_catalog_too_large", "Model catalog page exceeded its bounded wire contract.");
+    }
+    res.status(200).type("application/json").send(body);
+}
 function cronJobId(value) {
     const raw = typeof value === "string" ? value : undefined;
     const jobId = normalizeOptionalString(raw);
@@ -1421,6 +2085,16 @@ function sendBoundedCronJson(res, status, value) {
     }
     res.status(status).type("application/json").send(serialized);
 }
+/** A wake key identifies a flight; only the independent owner bearer authorizes it. */
+function authorizeMonitorWake(req, res, key, ownerBearer) {
+    if (typeof key !== "string" || !key.trim().startsWith("monitor:"))
+        return true;
+    const presented = readAuthorizationBearer(req.header("x-mono-agent-monitor-wake-authorization"));
+    if (ownerBearer !== undefined && presented !== undefined && bearerTokensEqual(presented, ownerBearer))
+        return true;
+    res.status(401).json({ error: { message: "Monitor wake requires owner authorization.", code: "invalid_api_key" } });
+    return false;
+}
 function authorize(req, res, apiKey) {
     if (apiKey === undefined) {
         return true;
@@ -1432,13 +2106,81 @@ function authorize(req, res, apiKey) {
     res.status(401).json({ error: { message: "Invalid API key.", code: "invalid_api_key" } });
     return false;
 }
+function boundedProviderAuthSessionId(value) {
+    return typeof value === "string" && value.length > 0 && Buffer.byteLength(value, "utf8") <= 128
+        ? value
+        : undefined;
+}
 function sendJsonError(res, status, error) {
-    res.status(status).json({
-        error: {
-            message: errorToMessage(error),
-            ...(codeOf(error) === undefined ? {} : { code: codeOf(error) }),
-        },
-    });
+    res.status(status).type("application/json").send(boundedErrorBody(error));
+}
+function sendContextImportError(res, status, code, message, reason) {
+    res.setHeader("Cache-Control", "private, no-store, max-age=0");
+    res.status(status).json({ error: { code, message, reason } });
+}
+/** Appended to a message the fence had to cut, so a reader is never handed a
+ * truncated diagnostic as if it were the whole one. */
+const TRUNCATED_MESSAGE_SUFFIX = "\u2026 [truncated]";
+/**
+ * Serialize one error envelope under the SHARED `/v1/info` body cap.
+ *
+ * `sendBoundedInfo` bounds a success body by shedding fields; an error body has
+ * no field to shed — it is one diagnostic message — so it is bounded by
+ * clamping that message instead, which is the one place truncating is
+ * obviously correct. Bounding success and not failure is not a wire contract:
+ * before this, a rejecting `info` provider answered whatever its message
+ * measured (a real probe: 1,052,696 bytes against a 1,048,576-byte cap),
+ * because the route's `.catch` lands here and this responder had no bound.
+ *
+ * `code` survives clamping — the console and the TUI switch on it — and the
+ * message keeps its head, so a clamped body still names what failed.
+ */
+function boundedErrorBody(error) {
+    const message = errorToMessage(error);
+    const rawCode = codeOf(error);
+    // A `code` is an identifier, kept whole whenever it can be. A "code" that
+    // alone overruns the cap is not an identifier, and dropping it is better than
+    // letting it crowd out the message that explains the failure.
+    const code = rawCode !== undefined
+        && Buffer.byteLength(errorEnvelope(TRUNCATED_MESSAGE_SUFFIX, rawCode), "utf8") <= MAX_INFO_BODY_BYTES
+        ? rawCode
+        : undefined;
+    const full = errorEnvelope(message, code);
+    if (Buffer.byteLength(full, "utf8") <= MAX_INFO_BODY_BYTES)
+        return full;
+    return errorEnvelope(clampErrorMessage(message, code), code);
+}
+function errorEnvelope(message, code) {
+    return JSON.stringify({ error: { message, ...(code === undefined ? {} : { code }) } });
+}
+/**
+ * A prefix of `message` whose envelope fits, plus the truncation marker.
+ *
+ * Measured against the SERIALIZED envelope, not the raw string, and shrunk in
+ * PROPORTION to how far over the envelope is. Both halves matter: the overshoot
+ * is counted in bytes while `kept` is counted in code units, and one unit can
+ * escape to six bytes (`\u0007` -> `\\u0007`), so subtracting a byte overshoot
+ * from a unit count deletes the entire message the moment escaping is heavy —
+ * leaving a body that is bounded but says nothing about what failed.
+ */
+function clampErrorMessage(message, code) {
+    let kept = message;
+    for (;;) {
+        const candidate = kept + TRUNCATED_MESSAGE_SUFFIX;
+        const bytes = Buffer.byteLength(errorEnvelope(candidate, code), "utf8");
+        // The marker-only envelope was proven to fit before this was called, so the
+        // loop cannot spin at length 0.
+        if (bytes <= MAX_INFO_BODY_BYTES || kept.length === 0)
+            return candidate;
+        // Never drop less than an eighth, so a proportion that barely moves (the
+        // envelope's own fixed overhead) still converges in O(log n) passes.
+        const proportional = Math.floor(kept.length * (MAX_INFO_BODY_BYTES / bytes));
+        kept = kept.slice(0, Math.min(proportional, kept.length - Math.ceil(kept.length / 8)));
+        // Never end on a lone high surrogate split out of a pair.
+        const last = kept.charCodeAt(kept.length - 1);
+        if (last >= 0xd800 && last <= 0xdbff)
+            kept = kept.slice(0, -1);
+    }
 }
 function sendBoundedJobs(res, jobs) {
     const body = serializeBoundedJobs(jobs);
@@ -1514,4 +2256,8 @@ function normalizeBasePath(basePath) {
     }
     return basePath.length === 1 ? "" : basePath.replace(/\/+$/u, "");
 }
+function boundedMonitorId(value) {
+    const monitorId = normalizeOptionalString(typeof value === "string" ? value : undefined);
+    return monitorId === undefined || monitorId.length > 256 ? undefined : monitorId;
+}
 //# sourceMappingURL=server.js.map