@noodleseed/one 0.147.0 → 0.148.0

package/node_modules/@noodle-borg/service/dist/routes/assistant-suggestions.js

@@ -0,0 +1,106 @@
+import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
+import { parseAssistantContextPreferences, surfaceEnvelope, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { assistantSuggestionsRequestSchema } from '@noodle-borg/wire-contracts';
+import { readJsonBody, sendJson } from '../http-util.js';
+import { resolveInvocationContextSnapshot } from '../invocation-context.js';
+import { generateInitialAssistantSuggestions } from './assistant-agent.js';
+import { applyBrowserCors, authenticateSession, now } from './assistant-route-http.js';
+import { sessionScopedTarget } from './assistant-session-target.js';
+/** Generate or replay the one bounded initial prompt set for a session whose config omitted it. */
+export async function handleAssistantSuggestions(req, res, deps) {
+    const session = await authenticateSession(req, res, deps);
+    if (!session)
+        return;
+    applyBrowserCors(req, res, session.origin);
+    const body = await readJsonBody(req, deps.maxBody);
+    if (!body.ok)
+        return sendJson(res, body.status, { error: body.error });
+    const parsed = assistantSuggestionsRequestSchema.safeParse(body.value);
+    if (!parsed.success)
+        return sendJson(res, 400, { error: 'invalid suggestions request' });
+    // The server enforces omission too: a modified client cannot spend a model call when the resolved
+    // developer/operator configuration supplied either exact prompts or an explicit empty array.
+    if (session.configuration?.assistant?.suggestedPrompts !== undefined) {
+        return writeEmptySuggestions(res, session.origin);
+    }
+    if (session.history.length > 0)
+        return writeEmptySuggestions(res, session.origin);
+    if (!(await publicSuggestionWorkIsAvailable(session, deps))) {
+        return sendJson(res, 429, {
+            error: 'assistant is unavailable right now',
+            code: 'daily_turn_budget_exhausted',
+        });
+    }
+    const claim = await deps.store.claimInitialSuggestions(session.id);
+    if (claim.disposition === 'ready') {
+        return writeSuggestions(res, session.origin, claim.prompts);
+    }
+    if (claim.disposition !== 'generate')
+        return writeEmptySuggestions(res, session.origin);
+    const target = await sessionScopedTarget(deps.registry, session);
+    if (!target) {
+        await deps.store.failInitialSuggestions(session.id);
+        return writeEmptySuggestions(res, session.origin);
+    }
+    const clientContext = parsed.data.clientContext === undefined
+        ? undefined
+        : parseAssistantContextPreferences(parsed.data.clientContext);
+    if (clientContext?.ok === false) {
+        await deps.store.failInitialSuggestions(session.id);
+        return sendJson(res, 400, { error: 'invalid client context' });
+    }
+    const context = await resolveInvocationContextSnapshot({
+        artifact: target.served.artifact,
+        executeDeps: withAssistantSessionExecutionAuthority(target.served.deps, target.served.artifact, session),
+        caller: session.caller,
+        instant: now(deps),
+        ...(session.preferences ? { applicationPreference: session.preferences } : {}),
+        ...(clientContext?.ok ? { clientHint: clientContext.value } : {}),
+    });
+    try {
+        const prompts = await generateInitialAssistantSuggestions(target, session, context, deps, parsed.data.modelContext, parsed.data.pageContext);
+        if (prompts.length === 0) {
+            await deps.store.failInitialSuggestions(session.id);
+            return writeEmptySuggestions(res, session.origin);
+        }
+        await deps.store.completeInitialSuggestions(session.id, prompts);
+        return writeSuggestions(res, session.origin, prompts);
+    }
+    catch {
+        await deps.store.failInitialSuggestions(session.id);
+        return writeEmptySuggestions(res, session.origin);
+    }
+}
+async function publicSuggestionWorkIsAvailable(session, deps) {
+    if (session.publicEmbedId === undefined)
+        return true;
+    const embed = await deps.publicEmbeds?.lookup(session.publicEmbedId);
+    if (!embed)
+        return false;
+    const bounds = session.modelSource !== 'noodle-managed'
+        ? undefined
+        : (await deps.managedModelResolver?.resolve({
+            tenant: session.tenant,
+            deploymentId: session.deploymentId,
+        }))?.publicAdmission;
+    const envelope = surfaceEnvelope(deps.admissionEnvelope ?? ADMISSION_DEFAULTS, embed, bounds);
+    return envelope.mintsPerDay > 0 && envelope.turnsPerDay > 0;
+}
+function writeSuggestions(res, origin, prompts) {
+    writeHeaders(res, origin);
+    res.write(`event: suggested_prompts\ndata: ${JSON.stringify({ phase: 'initial', prompts })}\n\n`);
+    res.end('event: done\ndata: {}\n\n');
+}
+function writeEmptySuggestions(res, origin) {
+    writeHeaders(res, origin);
+    res.end('event: done\ndata: {}\n\n');
+}
+function writeHeaders(res, origin) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-store',
+        'access-control-allow-origin': origin,
+        vary: 'Origin',
+    });
+}
+//# sourceMappingURL=assistant-suggestions.js.map

package/node_modules/@noodle-borg/service/dist/routes/assistant-transcript.js

@@ -18,7 +18,12 @@ export async function handleAssistantTranscript(req, res, deps) {
     if (!session)
         return;
     applyBrowserCors(req, res, session.origin);
-    const body = { entries: visibleTranscript(session.history) };
+    const body = {
+        entries: visibleTranscript(session.history),
+        ...(session.latestSuggestions?.phase === 'follow_up'
+            ? { suggestions: session.latestSuggestions }
+            : {}),
+    };
     // Parse before sending, like the session exchange: a contract break fails loudly here rather than
     // stranding deployed widgets (ADR 0151).
     assistantTranscriptResponseSchema.parse(body);

package/node_modules/@noodle-borg/service/dist/routes/assistant.js

@@ -1,6 +1,6 @@
 import { clientAddressBucket, } from '@noodle-borg/admission-limits/portable';
 import { assistantModelFailure, assistantModelSource, assistantModelTransport, } from '@noodle-borg/assistant-gateway/model-runtime';
-import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, effectiveAssistantBrowserConfiguration, isAssistantPageContext, isAssistantVerifiedClaims, parseAssistantContextPreferences, parseAssistantCustomerRouting, resumeTurnMessage, resumeUnavailableMessage, shouldAutoResume, surfaceBindingForOrigin, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, effectiveAssistantBrowserConfiguration, isAssistantPageContext, isAssistantVerifiedClaims, parseAssistantContextPreferences, parseAssistantCustomerRouting, refuseBridgeToolCall, refusePublicTurn, resumeTurnMessage, resumeUnavailableMessage, shouldAutoResume, surfaceBindingForOrigin, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { canonicalizeAuthorizationClaimValues } from '@noodle-borg/auth';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { tenantMcpUrl } from '@noodle-borg/module';
@@ -13,7 +13,6 @@ import { resolveInvocationContextSnapshot } from '../invocation-context.js';
 import { createAssistantTurnStats, runAgentTurn } from './assistant-agent.js';
 import { elevateAssistantSession } from './assistant-elevation.js';
 import { executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, resolveAssistantKnowledge, } from './assistant-knowledge.js';
-import { refusePublicTurn } from './assistant-public-turn.js';
 import { applyBrowserCors, assistantSessionEndpoints, authenticateSession, handleAssistantPreflight, now, } from './assistant-route-http.js';
 import { sessionScopedTarget } from './assistant-session-target.js';
 import { authorizeControlPlane } from './control-plane.js';
@@ -191,13 +190,16 @@ export async function handleAssistantTurn(req, res, deps) {
     let turn;
     let message;
     let resumedTool;
+    let suggestionsRequested = false;
     if (isRecord(body.value) && 'resume' in body.value) {
         // The one-shot post-sign-in resume (issue #1177): no user text, the pending intent is server
         // state. Admission runs FIRST so a refused resume stays armed for a retry; the consume is a
         // single statement, so two requests racing the arm cannot both run it.
-        if (!assistantResumeTurnRequestSchema.safeParse(body.value).success) {
+        const resumeResult = assistantResumeTurnRequestSchema.safeParse(body.value);
+        if (!resumeResult.success) {
             return sendJson(res, 400, { error: 'invalid turn request' });
         }
+        suggestionsRequested = resumeResult.data.suggestions === true;
         const refusal = await refusePublicTurn(deps, session, 'resume', addressBucket);
         if (refusal) {
             captureAssistantUsage(deps.captureRequestEvent, assistantRefusedTurnUsageRequestEvent(session, refusal.code, performance.now() - usageStartedAt));
@@ -242,6 +244,7 @@ export async function handleAssistantTurn(req, res, deps) {
             return sendJson(res, 400, { error: 'invalid turn request' });
         }
         turn = turnResult.data;
+        suggestionsRequested = turn.suggestions === true;
         message = turn.message;
         if (message.trim().length === 0) {
             return sendJson(res, 400, { error: '"message" must be a non-empty string' });
@@ -296,7 +299,15 @@ export async function handleAssistantTurn(req, res, deps) {
     };
     let turnCompleted = false;
     try {
-        await runAgentTurn(target, session, message.trim(), invocationContext, deps, emit, turn?.modelContext, turn?.pageContext, stats);
+        if (suggestionsRequested) {
+            try {
+                await deps.store.replaceLatestSuggestions(session.id, undefined);
+            }
+            catch {
+                // Suggestions are optional; the assistant turn remains authoritative.
+            }
+        }
+        await runAgentTurn(target, session, message.trim(), invocationContext, deps, emit, turn?.modelContext, turn?.pageContext, stats, suggestionsRequested);
         turnCompleted = true;
     }
     catch (error) {
@@ -367,6 +378,12 @@ export async function handleAssistantAppRequest(req, res, deps) {
         return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
     const method = body.value.method;
     const params = body.value.params;
+    // Answered before any resolution work, so a refused browser agent costs nothing (ADR 0220). The
+    // marker is client-declared: it selects a budget, never authority, which the session below decides.
+    const bridged = method === 'tools/call' && body.value.bridge === 'webmcp';
+    const refusal = bridged ? await refuseBridgeToolCall(deps, session) : undefined;
+    if (refusal)
+        return sendJson(res, refusal.status, { error: refusal.message, code: refusal.code });
     const knowledge = await resolveAssistantKnowledge(target.served);
     if (method === 'tools/list') {
         return sendJson(res, 200, mapToolsList(target.served.artifact, session.caller, {

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

@@ -21,6 +21,7 @@ export declare const assistantSessionResponseSchema: z.ZodObject<{
         apps: z.ZodOptional<z.ZodURL>;
         sandbox: z.ZodOptional<z.ZodURL>;
         transcript: z.ZodOptional<z.ZodURL>;
+        suggestions: z.ZodOptional<z.ZodURL>;
     }, z.core.$strip>;
     configuration: z.ZodOptional<z.ZodObject<{
         branding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -45,6 +46,10 @@ export declare const assistantTranscriptResponseSchema: z.ZodObject<{
         }>;
         text: z.ZodString;
     }, z.core.$strict>>;
+    suggestions: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodLiteral<"follow_up">;
+        prompts: z.ZodArray<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. */
@@ -78,9 +83,11 @@ export declare const assistantMessageTurnRequestSchema: z.ZodObject<{
         structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     }, z.core.$strict>>;
     pageContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 export declare const assistantResumeTurnRequestSchema: z.ZodObject<{
     resume: z.ZodLiteral<true>;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 export type AssistantMessageTurnRequest = z.infer<typeof assistantMessageTurnRequestSchema>;
 export declare const assistantTurnRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -97,10 +104,28 @@ export declare const assistantTurnRequestSchema: z.ZodUnion<readonly [z.ZodObjec
         structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
     }, z.core.$strict>>;
     pageContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>, z.ZodObject<{
     resume: z.ZodLiteral<true>;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>]>;
 export type AssistantTurnRequest = z.infer<typeof assistantTurnRequestSchema>;
+/** Fresh untrusted context for the optional initial-suggestions request. */
+export declare const assistantSuggestionsRequestSchema: z.ZodObject<{
+    clientContext: z.ZodOptional<z.ZodObject<{
+        locale: z.ZodOptional<z.ZodString>;
+        timeZone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    modelContext: z.ZodOptional<z.ZodObject<{
+        content: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>>>;
+        structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+    pageContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type AssistantSuggestionsRequest = z.infer<typeof assistantSuggestionsRequestSchema>;
 /**
  * Resolve one server-held assistant interaction. The client returns only its decision and optional
  * schema-constrained input; reviewed tool arguments remain server-held and cannot be substituted here.
@@ -109,12 +134,15 @@ export declare const assistantInteractionRequestSchema: z.ZodDiscriminatedUnion<
     id: z.ZodString;
     action: z.ZodLiteral<"accept">;
     content: z.ZodOptional<z.ZodJSONSchema>;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     action: z.ZodLiteral<"decline">;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     action: z.ZodLiteral<"cancel">;
+    suggestions: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>], "action">;
 export type AssistantInteractionRequest = z.infer<typeof assistantInteractionRequestSchema>;
 /**
@@ -204,6 +232,16 @@ export declare const assistantWireEventSchema: z.ZodUnion<readonly [z.ZodObject<
         continuation: z.ZodString;
         expiresAt: z.ZodString;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    event: z.ZodLiteral<string>;
+    data: z.ZodObject<{
+        turnId: z.ZodOptional<z.ZodString>;
+        phase: z.ZodEnum<{
+            follow_up: "follow_up";
+            initial: "initial";
+        }>;
+        prompts: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     event: z.ZodLiteral<string>;
     data: z.ZodObject<{

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

@@ -49,6 +49,8 @@ export const assistantSessionResponseSchema = z.object({
          * starts visually fresh exactly as before.
          */
         transcript: z.url().optional(),
+        /** Additive model-generated prompt suggestions; its presence is the client capability gate. */
+        suggestions: z.url().optional(),
     }),
     configuration: assistantSessionConfigurationSchema.optional(),
     /**
@@ -74,6 +76,13 @@ export const assistantTranscriptResponseSchema = z
     })
         .strict())
         .max(40),
+    suggestions: z
+        .object({
+        phase: z.literal('follow_up'),
+        prompts: z.array(z.string().trim().min(1).max(240)).max(3),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 const assistantModelContentPartSchema = z
@@ -120,23 +129,54 @@ export const assistantMessageTurnRequestSchema = z
         .optional(),
     modelContext: assistantModelContextUpdateSchema.optional(),
     pageContext: assistantPageContextSchema.optional(),
+    suggestions: z.literal(true).optional(),
 })
     .strict();
-export const assistantResumeTurnRequestSchema = z.object({ resume: z.literal(true) }).strict();
+export const assistantResumeTurnRequestSchema = z
+    .object({ resume: z.literal(true), suggestions: z.literal(true).optional() })
+    .strict();
 export const assistantTurnRequestSchema = z.union([
     assistantMessageTurnRequestSchema,
     assistantResumeTurnRequestSchema,
 ]);
+/** Fresh untrusted context for the optional initial-suggestions request. */
+export const assistantSuggestionsRequestSchema = z
+    .object({
+    clientContext: z
+        .object({ locale: z.string().max(160).optional(), timeZone: z.string().max(160).optional() })
+        .strict()
+        .optional(),
+    modelContext: assistantModelContextUpdateSchema.optional(),
+    pageContext: assistantPageContextSchema.optional(),
+})
+    .strict();
 /**
  * Resolve one server-held assistant interaction. The client returns only its decision and optional
  * schema-constrained input; reviewed tool arguments remain server-held and cannot be substituted here.
  */
 export const assistantInteractionRequestSchema = z.discriminatedUnion('action', [
     z
-        .object({ id: z.string().min(1), action: z.literal('accept'), content: z.json().optional() })
+        .object({
+        id: z.string().min(1),
+        action: z.literal('accept'),
+        content: z.json().optional(),
+        suggestions: z.literal(true).optional(),
+    })
+        .strict(),
+    z
+        .object({
+        id: z.string().min(1),
+        action: z.literal('decline'),
+        suggestions: z.literal(true).optional(),
+    })
+        .strict(),
+    z
+        .object({
+        id: z.string().min(1),
+        action: z.literal('cancel'),
+        suggestions: z.literal(true).optional(),
+    })
         .strict(),
-    z.object({ id: z.string().min(1), action: z.literal('decline') }).strict(),
-    z.object({ id: z.string().min(1), action: z.literal('cancel') }).strict(),
 ]);
 const optionalTurnId = z.string().min(1).optional();
 const eventEnvelope = (event, data) => z.object({ event: z.literal(event), data });
@@ -206,6 +246,11 @@ export const assistantWireEventSchema = z.union([
         continuation: z.string().min(1),
         expiresAt: z.string().min(1),
     })),
+    eventEnvelope('suggested_prompts', z.object({
+        turnId: optionalTurnId,
+        phase: z.enum(['initial', 'follow_up']),
+        prompts: z.array(z.string().trim().min(1).max(240)).max(3),
+    })),
     eventEnvelope('error', z.object({
         turnId: optionalTurnId,
         code: z.string().min(1),

package/node_modules/@noodleseed/assistant/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/assistant",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "Embed the Noodle Seed customer-branded assistant in your web app with managed or framework-owned UI, a framework-neutral MCP App host, a DOM-free client, and a backend session helper. Authoring and deploying the server is @noodleseed/one.",
   "license": "Apache-2.0",
   "repository": {

package/package.json

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

package/node_modules/@noodle-borg/service/dist/routes/assistant-public-turn.js

@@ -1,37 +0,0 @@
-import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
-import { admitPublicTurn } from '@noodle-borg/assistant-gateway/portable';
-import { now } from './assistant-route-http.js';
-export async function refusePublicTurn(deps, session, message, 
-/** Hashed by the caller; a raw address never reaches this far. */
-addressBucket) {
-    const publicEmbedId = session.publicEmbedId;
-    if (publicEmbedId === undefined)
-        return undefined;
-    const embeds = deps.publicEmbeds;
-    const counters = deps.admissionCounters;
-    if (!embeds || !counters) {
-        // Fail closed. A public session that reached a service with no counters would run unbounded
-        // against the customer's model budget, which is the one outcome the envelope exists to prevent.
-        return {
-            status: 503,
-            code: 'admission_unavailable',
-            message: 'assistant is unavailable right now',
-        };
-    }
-    const result = await admitPublicTurn({ sessionId: session.id, publicEmbedId, message, ...(addressBucket ? { addressBucket } : {}) }, deps.admissionEnvelope ?? ADMISSION_DEFAULTS, {
-        counters,
-        embeds,
-        resolveBudgetBounds: async () => session.modelSource !== 'noodle-managed'
-            ? undefined
-            : (await deps.managedModelResolver?.resolve({
-                tenant: session.tenant,
-                deploymentId: session.deploymentId,
-            }))?.publicAdmission,
-        consumeTurn: (id, limit) => deps.store.consumeTurn(id, limit),
-        now: () => now(deps),
-    });
-    return result.ok
-        ? undefined
-        : { status: result.status, code: result.code, message: result.message };
-}
-//# sourceMappingURL=assistant-public-turn.js.map