@noodleseed/one 0.139.4 → 0.141.0

package/node_modules/@noodle-borg/transport-http/dist/request-capture.js

@@ -1,3 +1,13 @@
+import { boundedClientName, boundedClientVersion, clientFamily, SessionClientMemo, sessionClientKey, } from './client-identity.js';
+/**
+ * Best-effort per-process memo from a legacy analytics session id to its `initialize` clientInfo, so
+ * legacy tool calls keep client attribution when the client supplies `Mcp-Session-Id` (#1309).
+ */
+let sessionClientMemo = new SessionClientMemo();
+/** Test seam: drop all memoized session client identities. */
+export function resetSessionClientMemo() {
+    sessionClientMemo = new SessionClientMemo();
+}
 /** JSON-RPC methods that are protocol discovery/chatter, excluded from usage metrics (ADR 0121). */
 const DISCOVERY_METHODS = new Set([
     'server/discover',
@@ -33,6 +43,25 @@ export function emitRequestEvent(input) {
     const failed = res.statusCode >= 400;
     const toolName = observed?.toolName ?? (method === 'tools/call' ? rpcTargetName(first, method) : undefined);
     const errorKind = observed?.errorKind ?? (failed ? `http_${res.statusCode}` : undefined);
+    // Client identity: the request's own clientInfo wins; a legacy request that supplies a session id
+    // falls back to the identity memoized from that session's `initialize` (#1309). Values are bounded.
+    let clientName = boundedClientName(modern?.clientName ?? init?.clientName);
+    let clientVersion = boundedClientVersion(modern?.clientVersion ?? init?.clientVersion);
+    if (sessionId !== undefined) {
+        const key = sessionClientKey(org, tenant?.app ?? auth.app, tenant?.env ?? auth.environment, sessionId);
+        if (method === 'initialize' && clientName !== undefined) {
+            sessionClientMemo.remember(key, {
+                clientName,
+                ...(clientVersion === undefined ? {} : { clientVersion }),
+            });
+        }
+        else if (clientName === undefined) {
+            const recalled = sessionClientMemo.recall(key);
+            clientName = recalled?.clientName;
+            clientVersion ??= recalled?.clientVersion;
+        }
+    }
+    const family = clientFamily(clientName, header(req, 'user-agent'));
     const event = {
         org,
         ...(tenant !== undefined ? { app: tenant.app, env: tenant.env } : {}),
@@ -43,16 +72,9 @@ export function emitRequestEvent(input) {
         requestId,
         ...(sessionId !== undefined ? { sessionId } : {}),
         sessionSource: sessionId !== undefined ? 'mcp' : 'none',
-        ...(modern?.clientName !== undefined
-            ? { clientName: modern.clientName }
-            : init?.clientName !== undefined
-                ? { clientName: init.clientName }
-                : {}),
-        ...(modern?.clientVersion !== undefined
-            ? { clientVersion: modern.clientVersion }
-            : init?.clientVersion !== undefined
-                ? { clientVersion: init.clientVersion }
-                : {}),
+        ...(clientName !== undefined ? { clientName } : {}),
+        ...(clientVersion !== undefined ? { clientVersion } : {}),
+        clientFamily: family,
         ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
         subjectKind: subject !== undefined ? 'authenticated' : 'anonymous',
         method,
@@ -63,9 +85,12 @@ export function emitRequestEvent(input) {
         outcome: observed?.outcome ?? (failed ? 'mcp_error' : 'ok'),
         ...(errorKind !== undefined ? { errorKind } : {}),
         durationMs: Date.now() - startedAt,
+        ...(input.timing?.queueMs !== undefined ? { queueMs: input.timing.queueMs } : {}),
+        ...(input.timing?.execMs !== undefined ? { execMs: input.timing.execMs } : {}),
         ...(observed?.outputTokensEst !== undefined
             ? { outputTokensEst: observed.outputTokensEst }
             : {}),
+        ...connectorDetails(observed),
     };
     try {
         capture(event);
@@ -74,6 +99,68 @@ export function emitRequestEvent(input) {
         // Analytics is strictly best-effort; a capture bug must never surface to the caller.
     }
 }
+/** Project the observation's safe connector attribution into the scalar-only `details` bag. */
+function connectorDetails(observed) {
+    const connector = observed?.connector;
+    if (connector === undefined)
+        return {};
+    return {
+        details: {
+            connectorId: connector.connectorId,
+            connectorVersion: connector.connectorVersion,
+            connectorOperation: connector.operation,
+            ...(connector.category !== undefined ? { connectorCategory: connector.category } : {}),
+            ...(connector.statusClass !== undefined
+                ? { connectorStatusClass: connector.statusClass }
+                : {}),
+            ...(connector.attempts !== undefined ? { connectorAttempts: connector.attempts } : {}),
+            ...(connector.retryable !== undefined ? { connectorRetryable: connector.retryable } : {}),
+        },
+    };
+}
+/**
+ * Reason a front-door denial (identity auth, admission, tool authorization) was sent before any
+ * protocol handler ran. Bounded reason tokens compose the analytics `errorKind` (#1309).
+ */
+export function emitDeniedRequestEvent(input) {
+    const { req, auth, tenant, target, parsed, startedAt, requestId, errorKind } = input;
+    const capture = auth.captureRequestEvent;
+    if (capture === undefined)
+        return;
+    const org = tenant?.org ?? auth.org;
+    if (org === undefined)
+        return;
+    const first = Array.isArray(parsed) ? parsed[0] : parsed;
+    const method = first === undefined ? 'unknown' : rpcMethod(first);
+    const toolName = method === 'tools/call' ? rpcTargetName(first, method) : undefined;
+    const modern = modernRequestInfo(first);
+    const sdkProtocolVersion = modern?.protocolVersion ?? header(req, 'mcp-protocol-version');
+    const event = {
+        org,
+        ...(tenant !== undefined ? { app: tenant.app, env: tenant.env } : {}),
+        ...(auth.deploymentId !== undefined ? { deploymentId: auth.deploymentId } : {}),
+        serverVersion: target.artifact.server.version,
+        ...(sdkProtocolVersion !== undefined ? { sdkProtocolVersion } : {}),
+        ...(first !== undefined ? { protocolEra: modern === undefined ? 'legacy' : 'modern' } : {}),
+        requestId,
+        sessionSource: 'none',
+        clientFamily: clientFamily(undefined, header(req, 'user-agent')),
+        ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
+        subjectKind: 'anonymous',
+        method,
+        kind: 'usage',
+        ...(toolName !== undefined ? { toolName } : {}),
+        outcome: 'mcp_error',
+        errorKind,
+        durationMs: Date.now() - startedAt,
+    };
+    try {
+        capture(event);
+    }
+    catch {
+        // Analytics is strictly best-effort.
+    }
+}
 /** Emit validated intent observations into their separate operator stream. */
 export function emitIntentEvents(input) {
     const { req, target, auth, tenant, parsed, observations, requestId } = input;

package/node_modules/@noodle-borg/transport-http/dist/serve-request.js

@@ -3,7 +3,7 @@ import { createDualEraMcpHandler, handleStatelessHttp, JSON_RPC, } from '@noodle
 import { admissionContexts, requestsInvocationContext } from './admission-context.js';
 import { authorizeIdentityMode, authorizeMixedMode, authorizePublicServiceMode, canonicalResourceUrl, isIdentityMode, } from './identity-authorization.js';
 import { invocationClientHint } from './invocation-client-hints.js';
-import { emitIntentEvents, emitRequestEvent, header } from './request-capture.js';
+import { emitDeniedRequestEvent, emitIntentEvents, emitRequestEvent, header, } from './request-capture.js';
 import { admissionRpcError, rpcError, sendJson } from './responses.js';
 import { preflightServicePrincipalToolCall, sendServicePrincipalToolDenial, } from './service-principal-authorization.js';
 import { preflightToolAuthorization, sendToolAuthorizationDenial } from './tool-authorization.js';
@@ -18,6 +18,22 @@ import { widgetDomainProjectionForRequest } from './widget-host.js';
 export async function serveRequest(req, res, target, auth, routeId, maxBody, allowed, tenant) {
     const startedAt = Date.now();
     const requestId = randomUUID();
+    // Every structured log line for this request carries the analytics correlation id (#1309).
+    // Field merge, not `child()`: injected loggers are only guaranteed the four level methods.
+    const logger = {
+        info: (event, fields) => auth.logger.info(event, { requestId, ...fields }),
+        warn: (event, fields) => auth.logger.warn(event, { requestId, ...fields }),
+    };
+    const denied = (errorKind, parsedBody) => emitDeniedRequestEvent({
+        req,
+        auth,
+        tenant,
+        target,
+        ...(parsedBody === undefined ? {} : { parsed: parsedBody }),
+        startedAt,
+        requestId,
+        errorKind,
+    });
     const origin = header(req, 'origin');
     if (origin !== undefined && !originAllowed(origin, allowed)) {
         return sendJson(res, 403, rpcError(JSON_RPC.INVALID_REQUEST, 'origin not allowed'));
@@ -37,7 +53,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
     if (isIdentityMode(auth.accessMode)) {
         const authResult = await authorizeIdentityMode(req, res, auth);
         if (!authResult.allow)
-            return;
+            return denied(`auth_denied.${authResult.reason}`);
         if (authResult.caller !== undefined) {
             protocolContext = {
                 ...protocolContext,
@@ -59,7 +75,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
     else if (auth.accessMode === 'mixed') {
         const authResult = await authorizeMixedMode(req, res, auth);
         if (!authResult.allow)
-            return;
+            return denied(`auth_denied.${authResult.reason}`);
         if (authResult.caller !== undefined) {
             protocolContext = {
                 ...protocolContext,
@@ -117,7 +133,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
         const decision = auth.admissionGate
             ? await auth.admissionGate(context)
             : { allow: true };
-        auth.logger.info('mcp.admission', {
+        logger.info('mcp.admission', {
             routeId: context.routeId,
             method: context.method,
             category: context.category,
@@ -134,12 +150,13 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
             if (decision.retryAfterSeconds !== undefined) {
                 res.setHeader('Retry-After', String(decision.retryAfterSeconds));
             }
-            return sendJson(res, decision.status ?? 403, admissionRpcError(context, decision));
+            sendJson(res, decision.status ?? 403, admissionRpcError(context, decision));
+            return denied(`admission_denied.${boundedReason(decision.reason)}`, parsed);
         }
     }
     const authorization = preflightToolAuthorization(parsed, target, protocolContext.caller);
     for (const observation of authorization.observations) {
-        auth.logger.info('mcp.tool_authorization', {
+        logger.info('mcp.tool_authorization', {
             toolName: observation.toolName,
             decision: observation.decision,
             reason: observation.reason,
@@ -149,12 +166,12 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
     }
     if (authorization.denial !== undefined) {
         sendToolAuthorizationDenial(req, res, auth, authorization.denial);
-        return;
+        return denied(`auth_denied.${authorization.denial.decision.reason}`, parsed);
     }
     const serviceAuthorization = preflightServicePrincipalToolCall(parsed, target, protocolContext.caller);
     const serviceSubject = protocolContext.caller?.identityKind === 'service' ? protocolContext.caller.subject : undefined;
     for (const observation of serviceAuthorization.observations) {
-        auth.logger.info('mcp.service_principal_tool_authorization', {
+        logger.info('mcp.service_principal_tool_authorization', {
             subject: serviceSubject,
             toolName: observation.toolName,
             decision: observation.decision,
@@ -176,7 +193,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
         }
         catch {
             try {
-                auth.logger.warn('mcp.tool_authorization.observer_failed', {
+                logger.warn('mcp.tool_authorization.observer_failed', {
                     toolName: observation.toolName,
                     decision: observation.decision,
                 });
@@ -188,7 +205,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
     }
     if (serviceAuthorization.denial !== undefined) {
         sendServicePrincipalToolDenial(res, serviceAuthorization.denial);
-        return;
+        return denied(`auth_denied.${serviceAuthorization.denial.reason}`, parsed);
     }
     if (auth.resolveInvocationContext !== undefined && requestsInvocationContext(parsed)) {
         const clientHint = invocationClientHint(parsed);
@@ -220,6 +237,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
             },
         };
     }
+    const dispatchedAt = Date.now();
     if (auth.protocolMode === 'legacy-only') {
         await handleStatelessHttp(target, req, res, parsed, protocolContext);
     }
@@ -251,9 +269,21 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
         observed,
         startedAt,
         requestId,
+        timing: { queueMs: dispatchedAt - startedAt, execMs: Date.now() - dispatchedAt },
     });
     emitIntentEvents({ req, target, auth, tenant, parsed, observations, requestId });
 }
+/** Bound a gate-supplied denial reason into a low-cardinality token for the analytics errorKind. */
+function boundedReason(reason) {
+    if (reason === undefined)
+        return 'denied';
+    const token = reason
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 32);
+    return token.length === 0 ? 'denied' : token;
+}
 export function originAllowed(origin, allowed) {
     if (allowed === undefined)
         return true;

package/node_modules/@noodle-borg/wire-contracts/dist/assistant.d.ts

@@ -20,6 +20,7 @@ export declare const assistantSessionResponseSchema: z.ZodObject<{
         interactions: z.ZodOptional<z.ZodURL>;
         apps: z.ZodOptional<z.ZodURL>;
         sandbox: z.ZodOptional<z.ZodURL>;
+        transcript: z.ZodOptional<z.ZodURL>;
     }, z.core.$strip>;
     configuration: z.ZodOptional<z.ZodObject<{
         branding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -30,6 +31,22 @@ export declare const assistantSessionResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AssistantSessionResponse = z.infer<typeof assistantSessionResponseSchema>;
+/**
+ * The bounded visible transcript (ADR 0141/0201 amendments 2026-08-26): only rows that actually
+ * appeared in the panel — never tool internals, tickets, or model-facing scaffolding. Bounded by the
+ * session history window (40 messages); a read spends no turn budget. Strict, because the service
+ * parses its own response before sending, like the session exchange.
+ */
+export declare const assistantTranscriptResponseSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            user: "user";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AssistantTranscriptResponse = z.infer<typeof assistantTranscriptResponseSchema>;
 /** MCP-Apps-shaped, author-selected renderer summary included on one assistant turn. */
 export declare const assistantModelContextUpdateSchema: z.ZodObject<{
     content: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/node_modules/@noodle-borg/wire-contracts/dist/assistant.js

@@ -42,6 +42,13 @@ export const assistantSessionResponseSchema = z.object({
          * published client falls back to the srcdoc proxy.
          */
         sandbox: z.url().optional(),
+        /**
+         * Additive bounded visible-transcript endpoint (ADR 0141/0201 amendments 2026-08-26): a
+         * session-token-authenticated POST returning what the panel may repaint after a full-page
+         * navigation — the sign-in redirect above all. Absent on older services; the widget then
+         * starts visually fresh exactly as before.
+         */
+        transcript: z.url().optional(),
     }),
     configuration: assistantSessionConfigurationSchema.optional(),
     /**
@@ -51,6 +58,24 @@ export const assistantSessionResponseSchema = z.object({
      */
     resume: z.object({ tool: z.string().min(1) }).optional(),
 });
+/**
+ * The bounded visible transcript (ADR 0141/0201 amendments 2026-08-26): only rows that actually
+ * appeared in the panel — never tool internals, tickets, or model-facing scaffolding. Bounded by the
+ * session history window (40 messages); a read spends no turn budget. Strict, because the service
+ * parses its own response before sending, like the session exchange.
+ */
+export const assistantTranscriptResponseSchema = z
+    .object({
+    entries: z
+        .array(z
+        .object({
+        role: z.enum(['user', 'assistant']),
+        text: z.string(),
+    })
+        .strict())
+        .max(40),
+})
+    .strict();
 const assistantModelContentPartSchema = z
     .object({ type: z.literal('text'), text: z.string() })
     .strict();

package/node_modules/@noodleseed/assistant/README.md

@@ -35,8 +35,8 @@ troubleshooting) lives at <https://docs.noodleseed.dev/guides/embedded-assistant
 the server itself is `@noodleseed/one` (`npm install -g @noodleseed/one`).
 
 If your page sends a `Content-Security-Policy`, allow the Noodle service origin in `connect-src` (turns and
-event streams) **and** `frame-src` (app widgets render inside a hosted sandbox document served from the
-service origin, `endpoints.sandbox`, so your `script-src` can stay strict). Details are in the guide's
+event streams) and the exact session-advertised `endpoints.sandbox` origin in `frame-src` (it may be a
+dedicated sandbox origin, so your `script-src` can stay strict). Details are in the guide's
 "Content-Security-Policy on your page" section.
 
 ## Quick start
@@ -410,13 +410,8 @@ import "@noodleseed/assistant/app-view";
 </template>
 ```
 
-Configure Vue's `isCustomElement` for `noodle-app-view`. Angular uses the same element with `[client]`,
-`[view]`, and `[theme]` property bindings. Do not serialize `client` or `view` into attributes.
-
-`<noodle-app-view>` is the canonical host; `NoodleAppView` delegates to it. Both use the
-service-advertised sandbox URL, route App calls through the supplied client, publish theme changes without
-replacing the iframe, and request standard teardown on semantic replacement, disconnect, or an App teardown
-request.
+Framework setup, lifecycle ownership, sandbox/CSP behavior, and staged diagnostics are owned by the
+[Bring your own UI guide](https://docs.noodleseed.dev/docs/guides/bring-your-own-ui).
 
 The App document owns its action intent: it calls standard `tools/call` after connecting and never relies on
 native form navigation. If that call needs input or confirmation, the same `client` publishes the normal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.139.4",
+  "version": "0.141.0",
   "private": false,
   "description": "Noodle CLI by Noodle Seed — author, run, and deploy declarative MCP servers. Embedding the assistant in your own web app is @noodleseed/assistant.",
   "license": "Apache-2.0",