@noodleseed/one 0.191.0 → 0.192.1

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-guide.d.ts

@@ -3,7 +3,7 @@ import { type ToolAuthorizationCaller } from '@noodle-borg/protocol';
 import { type SurfaceCapabilityRef } from './artifact-projection.js';
 /** Model-context budget for the embedded assistant's compact product workflow projection. */
 export declare const ASSISTANT_GUIDE_MAX_BYTES: number;
-export type AssistantGuideUnavailableReason = 'package_unavailable' | 'no_complete_workflow';
+export type AssistantGuideUnavailableReason = 'package_unavailable';
 /**
  * What a guide over {@link ASSISTANT_GUIDE_MAX_BYTES} gave up to fit. Size never removes the guide:
  * purpose, use cases, boundaries, and one index line per workflow always survive, so a business with
@@ -88,6 +88,8 @@ export declare function assistantModelToolOncePerSession(tool: ArtifactTool): bo
 /**
  * Build bounded product guidance from structured App Package data, never from rendered host files.
  * Workflows are atomic: if one step is unavailable to this model, the entire workflow is omitted.
+ * When none survives (an anonymous visitor, a tool-less turn), the guide still carries purpose, use
+ * cases, and boundaries: they must be safe for every audience, so the caller's identity never removes them.
  *
  * Over budget, detail is shed in one fixed order until the guide fits: first every example, then each
  * workflow's intent and steps, last authored workflow first, leaving its index line (id, title, when to

package/node_modules/@noodle-borg/assistant-gateway/dist/assistant-guide.js

@@ -125,6 +125,8 @@ function normalizeVisibilityText(value) {
 /**
  * Build bounded product guidance from structured App Package data, never from rendered host files.
  * Workflows are atomic: if one step is unavailable to this model, the entire workflow is omitted.
+ * When none survives (an anonymous visitor, a tool-less turn), the guide still carries purpose, use
+ * cases, and boundaries: they must be safe for every audience, so the caller's identity never removes them.
  *
  * Over budget, detail is shed in one fixed order until the guide fits: first every example, then each
  * workflow's intent and steps, last authored workflow first, leaving its index line (id, title, when to
@@ -133,14 +135,12 @@ function normalizeVisibilityText(value) {
 export function projectAssistantGuide(input) {
     const parsed = appPackageArtifactV1Schema.safeParse(input.appPackage);
     if (!parsed.success)
-        return unavailable('package_unavailable');
+        return { status: 'unavailable', reason: 'package_unavailable' };
     const projected = projectAppPackageCapabilities(parsed.data, {
         tools: input.modelTools.map((tool) => tool.name),
         resources: [],
         prompts: [],
-    });
-    if (projected === undefined)
-        return unavailable('no_complete_workflow');
+    }) ?? { ...parsed.data, skill: { ...parsed.data.skill, workflows: [], examples: [] } };
     const workflows = projected.skill.workflows;
     const workflowIds = workflows.map((workflow) => workflow.id);
     let content = renderGuide(projected, { examples: true, indexOnly: [] });
@@ -179,7 +179,9 @@ function renderGuide(appPackage, shed) {
         `Product purpose: ${oneLine(skill.description)}`,
         'Use when:',
         ...skill.useWhen.map((value) => `- ${oneLine(value)}`),
-        'Workflows:',
+        ...(workflows.length === 0
+            ? ['No product workflows are available in this conversation.']
+            : ['Workflows:']),
     ];
     for (const workflow of workflows) {
         if (indexOnly.has(workflow.id)) {
@@ -252,7 +254,4 @@ function behaviorFacts(behavior) {
 function oneLine(value) {
     return value.replace(/\s+/g, ' ').trim();
 }
-function unavailable(reason) {
-    return { status: 'unavailable', reason };
-}
 //# sourceMappingURL=assistant-guide.js.map

package/node_modules/@noodle-borg/protocol/dist/v2/handler.d.ts

@@ -1,12 +1,8 @@
-import { type McpHttpHandler, type McpServerFactory } from '@modelcontextprotocol/server';
+import type { McpHttpHandler } from '@modelcontextprotocol/server';
 import type { ProtocolRequestContext, ServedArtifact } from '../sdk-server.js';
-import { type McpProtocolMode } from './versions.js';
+export { createPlatformDualEraMcpHandler } from './platform-handler.js';
 /**
  * The single Noodle MCP entry: SDK-owned era classification/dispatch with a narrow Noodle response seam.
  */
 export declare function createDualEraMcpHandler(target: ServedArtifact, context?: ProtocolRequestContext): McpHttpHandler;
-/** Platform-wide SDK v2 handler used by artifact and first-party MCP surfaces alike. */
-export declare function createPlatformDualEraMcpHandler(factory: McpServerFactory, platformOptions?: {
-    readonly protocolMode?: McpProtocolMode;
-}): McpHttpHandler;
 //# sourceMappingURL=handler.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/v2/handler.js

@@ -1,10 +1,10 @@
 import { randomBytes } from 'node:crypto';
-import { createMcpHandler, isLegacyRequest, } from '@modelcontextprotocol/server';
 import { notify } from '../observation.js';
 import { RequestStateManager, requestStateSecretBox } from '../request-state.js';
+import { createPlatformDualEraMcpHandlerInternal } from './platform-handler.js';
 import { protocolErrorObservation } from './response-observation.js';
 import { buildDualEraMcpServer } from './server.js';
-import { SERVED_MCP_PROTOCOL_VERSIONS } from './versions.js';
+export { createPlatformDualEraMcpHandler } from './platform-handler.js';
 /**
  * The single Noodle MCP entry: SDK-owned era classification/dispatch with a narrow Noodle response seam.
  */
@@ -24,40 +24,6 @@ export function createDualEraMcpHandler(target, context = {}) {
         finish: (request) => requestObservations.delete(request),
     });
 }
-/** Platform-wide SDK v2 handler used by artifact and first-party MCP surfaces alike. */
-export function createPlatformDualEraMcpHandler(factory, platformOptions = {}) {
-    return createPlatformDualEraMcpHandlerInternal(factory, platformOptions);
-}
-function createPlatformDualEraMcpHandlerInternal(factory, platformOptions = {}, hooks) {
-    const sdkHandler = createMcpHandler(factory, { legacy: 'stateless' });
-    return {
-        ...sdkHandler,
-        fetch: async (request, options) => {
-            hooks?.begin(request);
-            try {
-                const legacy = await isLegacyRequest(request.clone(), options?.parsedBody);
-                const requestBody = await readRequestBody(request, options?.parsedBody);
-                if (platformOptions.protocolMode === 'legacy-only' && !legacy) {
-                    return new Response(JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: requestId(requestBody),
-                        error: { code: -32601, message: 'Method not found' },
-                    }), { status: 200, headers: { 'content-type': 'application/json' } });
-                }
-                const response = await sdkHandler.fetch(request, {
-                    ...options,
-                    ...(requestBody === undefined ? {} : { parsedBody: requestBody }),
-                });
-                const shaped = await shapeNoodleResponse(response, requestBody, legacy);
-                await observeResponseBestEffort(hooks, request, requestBody, shaped);
-                return shaped;
-            }
-            finally {
-                hooks?.finish(request);
-            }
-        },
-    };
-}
 const processRequestState = new RequestStateManager(requestStateSecretBox(randomBytes(32)));
 function requestProtocolContext(context, requestContext) {
     return {
@@ -79,26 +45,6 @@ function observedProtocolContext(context, requestContext, requestObservations) {
         },
     };
 }
-async function observeResponseBestEffort(hooks, request, requestBody, response) {
-    try {
-        await hooks?.observeResponse(request, requestBody, response);
-    }
-    catch {
-        // Protocol analytics must never change the response it observes.
-    }
-}
-async function readRequestBody(request, parsedBody) {
-    if (parsedBody !== undefined)
-        return parsedBody;
-    if (request.method.toUpperCase() !== 'POST')
-        return undefined;
-    try {
-        return await request.clone().json();
-    }
-    catch {
-        return undefined;
-    }
-}
 async function readResponseBody(response) {
     const contentType = response.headers.get('content-type');
     if (contentType?.split(';', 1)[0]?.trim().toLowerCase() !== 'application/json')
@@ -110,104 +56,4 @@ async function readResponseBody(response) {
         return undefined;
     }
 }
-async function shapeNoodleResponse(response, requestBody, legacy) {
-    const contentType = response.headers.get('content-type');
-    if (legacy && contentType?.split(';', 1)[0]?.trim().toLowerCase() === 'text/event-stream') {
-        const eventStream = await response.text();
-        const eventData = firstServerSentEventData(eventStream);
-        if (eventData === undefined)
-            return copyResponse(response, eventStream);
-        const headers = new Headers(response.headers);
-        headers.set('content-type', 'application/json');
-        return shapeNoodleResponse(new Response(eventData, {
-            status: response.status,
-            statusText: response.statusText,
-            headers,
-        }), requestBody, legacy);
-    }
-    if (contentType?.split(';', 1)[0]?.trim().toLowerCase() !== 'application/json')
-        return response;
-    const text = await response.text();
-    let body;
-    try {
-        body = JSON.parse(text);
-    }
-    catch {
-        return copyResponse(response, text);
-    }
-    if (!isRecord(body))
-        return copyResponse(response, text);
-    const method = requestMethod(requestBody);
-    const id = requestId(requestBody);
-    const error = isRecord(body.error) ? body.error : undefined;
-    const result = isRecord(body.result) ? body.result : undefined;
-    let status = response.status;
-    if (!legacy && method === 'initialize') {
-        status = 400;
-        body = {
-            jsonrpc: '2.0',
-            error: {
-                code: -32022,
-                message: 'Unsupported protocol version',
-                data: {
-                    supported: [...SERVED_MCP_PROTOCOL_VERSIONS],
-                    requested: '2026-07-28',
-                },
-            },
-            id,
-        };
-    }
-    else if (error?.code === -32022 && isRecord(error.data)) {
-        error.data.supported = [...SERVED_MCP_PROTOCOL_VERSIONS];
-    }
-    else if (legacy && error !== undefined && typeof error.code === 'number') {
-        const code = method === 'resources/read' && error.code === -32602 ? -32002 : error.code;
-        const rawMessage = typeof error.message === 'string'
-            ? error.message.replace(/^MCP error -?\d+: /, '')
-            : 'Protocol error';
-        body = {
-            jsonrpc: '2.0',
-            id,
-            error: {
-                code,
-                message: `MCP error ${code}: ${rawMessage}`,
-                ...(error.data === undefined ? {} : { data: error.data }),
-            },
-        };
-    }
-    else if (!legacy && method === 'server/discover' && result !== undefined) {
-        result.supportedVersions = [...SERVED_MCP_PROTOCOL_VERSIONS];
-    }
-    return copyResponse(response, JSON.stringify(body), status);
-}
-function copyResponse(response, body, status = response.status) {
-    return new Response(body, {
-        status,
-        statusText: response.statusText,
-        headers: response.headers,
-    });
-}
-function firstServerSentEventData(body) {
-    for (const event of body.split(/\r?\n\r?\n/)) {
-        const data = event
-            .split(/\r?\n/)
-            .filter((line) => line.startsWith('data:'))
-            .map((line) => line.slice(5).trimStart())
-            .join('\n');
-        if (data.length > 0)
-            return data;
-    }
-    return undefined;
-}
-function requestMethod(body) {
-    return isRecord(body) && typeof body.method === 'string' ? body.method : undefined;
-}
-function requestId(body) {
-    if (!isRecord(body))
-        return null;
-    return typeof body.id === 'string' || typeof body.id === 'number' ? body.id : null;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 //# sourceMappingURL=handler.js.map

package/node_modules/@noodle-borg/protocol/dist/v2/platform-handler.d.ts

@@ -0,0 +1,15 @@
+import { type McpHttpHandler, type McpServerFactory } from '@modelcontextprotocol/server';
+import { type McpProtocolMode } from './versions.js';
+/** Platform-wide SDK v2 handler used by artifact and first-party MCP surfaces alike. */
+export declare function createPlatformDualEraMcpHandler(factory: McpServerFactory, platformOptions?: {
+    readonly protocolMode?: McpProtocolMode;
+}): McpHttpHandler;
+export interface PlatformHandlerHooks {
+    readonly begin: (request: Request) => void;
+    readonly observeResponse: (request: Request, requestBody: unknown, response: Response) => void | Promise<void>;
+    readonly finish: (request: Request) => void;
+}
+export declare function createPlatformDualEraMcpHandlerInternal(factory: McpServerFactory, platformOptions?: {
+    readonly protocolMode?: McpProtocolMode;
+}, hooks?: PlatformHandlerHooks): McpHttpHandler;
+//# sourceMappingURL=platform-handler.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/v2/platform-handler.js

@@ -0,0 +1,157 @@
+import { createMcpHandler, isLegacyRequest, } from '@modelcontextprotocol/server';
+import { SERVED_MCP_PROTOCOL_VERSIONS } from './versions.js';
+/** Platform-wide SDK v2 handler used by artifact and first-party MCP surfaces alike. */
+export function createPlatformDualEraMcpHandler(factory, platformOptions = {}) {
+    return createPlatformDualEraMcpHandlerInternal(factory, platformOptions);
+}
+export function createPlatformDualEraMcpHandlerInternal(factory, platformOptions = {}, hooks) {
+    const sdkHandler = createMcpHandler(factory, { legacy: 'stateless' });
+    return {
+        ...sdkHandler,
+        fetch: async (request, options) => {
+            hooks?.begin(request);
+            try {
+                const legacy = await isLegacyRequest(request.clone(), options?.parsedBody);
+                const requestBody = await readRequestBody(request, options?.parsedBody);
+                if (platformOptions.protocolMode === 'legacy-only' && !legacy) {
+                    return new Response(JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: requestId(requestBody),
+                        error: { code: -32601, message: 'Method not found' },
+                    }), { status: 200, headers: { 'content-type': 'application/json' } });
+                }
+                const response = await sdkHandler.fetch(request, {
+                    ...options,
+                    ...(requestBody === undefined ? {} : { parsedBody: requestBody }),
+                });
+                const shaped = await shapeNoodleResponse(response, requestBody, legacy);
+                await observeResponseBestEffort(hooks, request, requestBody, shaped);
+                return shaped;
+            }
+            finally {
+                hooks?.finish(request);
+            }
+        },
+    };
+}
+async function observeResponseBestEffort(hooks, request, requestBody, response) {
+    try {
+        await hooks?.observeResponse(request, requestBody, response);
+    }
+    catch {
+        // Protocol analytics must never change the response it observes.
+    }
+}
+async function readRequestBody(request, parsedBody) {
+    if (parsedBody !== undefined)
+        return parsedBody;
+    if (request.method.toUpperCase() !== 'POST')
+        return undefined;
+    try {
+        return await request.clone().json();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function shapeNoodleResponse(response, requestBody, legacy) {
+    const contentType = response.headers.get('content-type');
+    if (legacy && contentType?.split(';', 1)[0]?.trim().toLowerCase() === 'text/event-stream') {
+        const eventStream = await response.text();
+        const eventData = firstServerSentEventData(eventStream);
+        if (eventData === undefined)
+            return copyResponse(response, eventStream);
+        const headers = new Headers(response.headers);
+        headers.set('content-type', 'application/json');
+        return shapeNoodleResponse(new Response(eventData, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        }), requestBody, legacy);
+    }
+    if (contentType?.split(';', 1)[0]?.trim().toLowerCase() !== 'application/json')
+        return response;
+    const text = await response.text();
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return copyResponse(response, text);
+    }
+    if (!isRecord(body))
+        return copyResponse(response, text);
+    const method = requestMethod(requestBody);
+    const id = requestId(requestBody);
+    const error = isRecord(body.error) ? body.error : undefined;
+    const result = isRecord(body.result) ? body.result : undefined;
+    let status = response.status;
+    if (!legacy && method === 'initialize') {
+        status = 400;
+        body = {
+            jsonrpc: '2.0',
+            error: {
+                code: -32022,
+                message: 'Unsupported protocol version',
+                data: {
+                    supported: [...SERVED_MCP_PROTOCOL_VERSIONS],
+                    requested: '2026-07-28',
+                },
+            },
+            id,
+        };
+    }
+    else if (error?.code === -32022 && isRecord(error.data)) {
+        error.data.supported = [...SERVED_MCP_PROTOCOL_VERSIONS];
+    }
+    else if (legacy && error !== undefined && typeof error.code === 'number') {
+        const code = method === 'resources/read' && error.code === -32602 ? -32002 : error.code;
+        const rawMessage = typeof error.message === 'string'
+            ? error.message.replace(/^MCP error -?\d+: /, '')
+            : 'Protocol error';
+        body = {
+            jsonrpc: '2.0',
+            id,
+            error: {
+                code,
+                message: `MCP error ${code}: ${rawMessage}`,
+                ...(error.data === undefined ? {} : { data: error.data }),
+            },
+        };
+    }
+    else if (!legacy && method === 'server/discover' && result !== undefined) {
+        result.supportedVersions = [...SERVED_MCP_PROTOCOL_VERSIONS];
+    }
+    return copyResponse(response, JSON.stringify(body), status);
+}
+function copyResponse(response, body, status = response.status) {
+    return new Response(body, {
+        status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+function firstServerSentEventData(body) {
+    for (const event of body.split(/\r?\n\r?\n/)) {
+        const data = event
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice(5).trimStart())
+            .join('\n');
+        if (data.length > 0)
+            return data;
+    }
+    return undefined;
+}
+function requestMethod(body) {
+    return isRecord(body) && typeof body.method === 'string' ? body.method : undefined;
+}
+function requestId(body) {
+    if (!isRecord(body))
+        return null;
+    return typeof body.id === 'string' || typeof body.id === 'number' ? body.id : null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=platform-handler.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.191.0",
+  "version": "0.192.1",
   "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",