@noodleseed/one 0.147.1 → 0.149.0

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

@@ -34,13 +34,22 @@ async function handleResolution(req, res, deps, legacyAcceptOnly) {
     const response = parseInteractionResponse(body.value, legacyAcceptOnly);
     if (!response.ok)
         return sendJson(res, 400, { error: response.error });
+    const suggestions = response.value.suggestions === true;
+    if (suggestions) {
+        try {
+            await deps.store.replaceLatestSuggestions(session.id, undefined);
+        }
+        catch {
+            // Suggestions are optional; interaction resolution remains authoritative.
+        }
+    }
     const scope = assistantInteractionScope(response.value.id, session, now(deps));
     const interaction = await deps.store.getInteraction(scope);
     if (!interaction) {
         return sendJson(res, 409, { error: 'interaction is invalid or expired' });
     }
     if (response.value.action !== 'accept') {
-        return resolveStop(res, deps, session, interaction, response.value.action);
+        return resolveStop(res, deps, session, interaction, response.value.action, suggestions);
     }
     if (interaction.kind === 'confirmation' && response.value.content !== undefined) {
         return sendJson(res, 400, { error: 'confirmation content cannot replace reviewed arguments' });
@@ -67,9 +76,9 @@ async function handleResolution(req, res, deps, legacyAcceptOnly) {
         }
         acceptedContent = validated.value;
     }
-    return resolveAccept(res, deps, session, interaction, acceptedContent);
+    return resolveAccept(res, deps, session, interaction, acceptedContent, suggestions);
 }
-async function resolveAccept(res, deps, session, interaction, content) {
+async function resolveAccept(res, deps, session, interaction, content, suggestions) {
     if (interaction.status !== 'pending') {
         return replayOrConflict(res, deps, session, interaction, 'accept');
     }
@@ -149,9 +158,9 @@ async function resolveAccept(res, deps, session, interaction, content) {
             ? await resumeToolPreparation(target.served.artifact, continuation, { action: 'accept', content }, executeDeps)
             : await resumeTool(target.served.artifact, continuation, { action: 'accept', content }, executeDeps);
     }
-    return finishExecution(res, deps, session, claimed.interaction, context, result, target);
+    return finishExecution(res, deps, session, claimed.interaction, context, result, target, suggestions);
 }
-async function finishExecution(res, deps, session, interaction, context, result, target) {
+async function finishExecution(res, deps, session, interaction, context, result, target, suggestions) {
     const toolName = assistantInteractionTool(interaction) ?? 'unknown_tool';
     if (result.status === 'confirmation_required') {
         const tool = target.served.artifact.tools.find((candidate) => candidate.name === toolName);
@@ -357,10 +366,10 @@ async function finishExecution(res, deps, session, interaction, context, result,
     }, (failure) => deps.logger?.warn('assistant.view.unresolved', { ...failure }));
     if (view)
         writeViewAvailable(res, view);
-    await narrateResolvedInteraction(res, deps, target, session, toolName, 'accept', safeOutput, context);
+    await narrateResolvedInteraction(res, deps, target, session, toolName, 'accept', safeOutput, context, suggestions);
     return endInteractionSse(res);
 }
-async function resolveStop(res, deps, session, interaction, action) {
+async function resolveStop(res, deps, session, interaction, action, suggestions) {
     if (interaction.status !== 'pending') {
         return replayOrConflict(res, deps, session, interaction, action);
     }
@@ -426,7 +435,7 @@ async function resolveStop(res, deps, session, interaction, action) {
     writeInteractionSseHeaders(res, session.origin);
     writeInteractionResolved(res, interaction.id, action);
     if (target && context) {
-        await narrateResolvedInteraction(res, deps, target, session, toolName, action, undefined, context);
+        await narrateResolvedInteraction(res, deps, target, session, toolName, action, undefined, context, suggestions);
     }
     return endInteractionSse(res);
 }

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

@@ -5,10 +5,7 @@ export async function resolveAssistantModelBinding(target, tenant, deploymentId,
     if (declaration === undefined)
         return undefined;
     if (declaration.kind === 'noodle-managed') {
-        return deps.managedModelResolver?.resolve({
-            tenant,
-            deploymentId,
-        });
+        return deps.managedModelResolver?.resolve({ tenant, deploymentId });
     }
     const scope = resolveConfigScope(tenant);
     const [variables, secrets] = await Promise.all([

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

@@ -1,7 +1,7 @@
 import { randomBytes } from 'node:crypto';
 import { ADMISSION_DEFAULTS, clientAddressBucket } from '@noodle-borg/admission-limits/portable';
 import { effectiveAssistantBrowserConfiguration, mintPublicSession, publicEmbedTenant, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
-import { assistantSessionUsageRequestEvent, captureAssistantUsage, } from '@noodle-borg/observability';
+import { assistantSessionUsageRequestEvent, captureAssistantUsage, captureRefusedAssistantSession, } from '@noodle-borg/observability';
 import { assistantSessionResponseSchema } from '@noodle-borg/wire-contracts';
 import { readJsonBody, sendJson } from '../http-util.js';
 import { applyBrowserCors, assistantSessionEndpoints, now } from './assistant-route-http.js';
@@ -25,7 +25,7 @@ export async function handlePublicAssistantSession(req, res, deps) {
     const body = await readJsonBody(req, deps.maxBody);
     if (!body.ok)
         return sendJson(res, body.status, { error: body.error });
-    const { embedId } = body.value;
+    const { embedId, visitorId } = body.value;
     // The browser's Origin header is the claim under test. The body never asserts its own origin.
     const origin = typeof req.headers.origin === 'string' ? req.headers.origin : undefined;
     // Admission tier 3. Hashed here so no raw address crosses into the decision, a counter key, or an
@@ -36,7 +36,7 @@ export async function handlePublicAssistantSession(req, res, deps) {
     let configuration;
     let sponsoredBudget;
     let usageSession;
-    const result = await mintPublicSession({ embedId, origin, ...(addressBucket ? { addressBucket } : {}) }, deps.admissionEnvelope ?? ADMISSION_DEFAULTS, {
+    const result = await mintPublicSession({ embedId, visitorId, origin, ...(addressBucket ? { addressBucket } : {}) }, deps.admissionEnvelope ?? ADMISSION_DEFAULTS, {
         embeds,
         counters,
         resolveActiveSurface: async (embed) => {
@@ -86,6 +86,10 @@ export async function handlePublicAssistantSession(req, res, deps) {
         now: () => now(deps),
     });
     if (!result.ok) {
+        // A refusal the surface owns is usage. Without it an operator whose visitors are being turned
+        // away sees a healthy-looking page; which refusals count is the helper's decision, not this one's.
+        const refusedIn = performance.now() - usageStartedAt;
+        captureRefusedAssistantSession(deps.captureRequestEvent, result, refusedIn);
         return sendJson(res, result.status, { error: result.message, code: result.code });
     }
     // Only here, with the origin proven against the live surface, may the page read the response.

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

@@ -56,6 +56,7 @@ export function assistantSessionEndpoints(base) {
         apps: `${base}/v1/assistant/apps`,
         sandbox: `${base}/v1/assistant/sandbox`,
         transcript: `${base}/v1/assistant/transcript`,
+        suggestions: `${base}/v1/assistant/suggestions`,
     };
 }
 //# sourceMappingURL=assistant-route-http.js.map

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

@@ -1,49 +1,6 @@
-import { authenticatedSurfaceOf, projectArtifactForSurface, publicSurfaceOf, surfaceBindingForOrigin, } from '@noodle-borg/assistant-gateway/portable';
-export async function sessionScopedTarget(registry, session) {
-    const target = await registry.get(session.deploymentId);
-    if (!target)
-        return undefined;
-    const assistant = target.served.artifact.server.assistant;
-    const bound = session.boundSurface ?? deriveLegacyBinding(assistant, session);
-    if (bound === 'pre-surfaces')
-        return target;
-    // Fail closed: an origin no surface owns must never widen to the whole server.
-    if (bound === 'unowned')
-        return undefined;
-    // Fail closed on a vanished surface. A rollback to an artifact without the bound surface must end the
-    // session's reach, never hand it the unprojected server.
-    if (bound === 'authenticated') {
-        const surface = authenticatedSurfaceOf(assistant);
-        if (surface === undefined)
-            return undefined;
-        // An omitted allowlist on an authenticated surface is the authored whole-server intent, so the
-        // exact binding still holds (instructions, budgets, attribution) without narrowing capabilities.
-        if (surface.capabilities === undefined)
-            return target;
-        return projected(target, surface.capabilities);
-    }
-    const surface = publicSurfaceOf(assistant);
-    if (surface === undefined)
-        return undefined;
-    return projected(target, surface.capabilities);
-}
-function projected(target, capabilities) {
-    return {
-        ...target,
-        served: {
-            ...target.served,
-            artifact: projectArtifactForSurface(target.served.artifact, capabilities),
-        },
-    };
-}
-/**
- * A record minted before `boundSurface` existed: the embed id marks the public surface; otherwise the
- * session's origin selects the owning surface on the pinned deployment. `pre-surfaces` means the whole
- * server on that released artifact shape; `unowned` fails closed above.
- */
-function deriveLegacyBinding(assistant, session) {
-    if (session.publicEmbedId !== undefined)
-        return 'public';
-    return surfaceBindingForOrigin(assistant, session.origin).kind;
+import { resolveAssistantSessionTarget, } from '@noodle-borg/assistant-gateway/portable';
+/** Adapt the registry to the gateway-owned, surface-projected session target decision. */
+export function sessionScopedTarget(registry, session) {
+    return resolveAssistantSessionTarget((deploymentId) => registry.get(deploymentId), session);
 }
 //# sourceMappingURL=assistant-session-target.js.map

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';
@@ -175,6 +174,16 @@ export async function handleAssistantSession(req, res, deps) {
     captureAssistantUsage(deps.captureRequestEvent, assistantSessionUsageRequestEvent(session.session, performance.now() - usageStartedAt));
     return sendJson(res, 201, sessionBody);
 }
+/**
+ * Both turn entries — a resume and a typed message — refuse identically: the refusal is spent
+ * budget, so it is recorded against the surface before the caller is told no. Kept in one place so
+ * the two entries cannot drift into recording it differently.
+ */
+function refuseTurn(deps, res, session, refusal, usageStartedAt) {
+    const durationMs = performance.now() - usageStartedAt;
+    captureAssistantUsage(deps.captureRequestEvent, assistantRefusedTurnUsageRequestEvent(session, refusal.code, durationMs));
+    sendJson(res, refusal.status, { error: refusal.message, code: refusal.code });
+}
 export async function handleAssistantTurn(req, res, deps) {
     const usageStartedAt = performance.now();
     const session = await authenticateSession(req, res, deps);
@@ -191,18 +200,19 @@ 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));
-            return sendJson(res, refusal.status, { error: refusal.message, code: refusal.code });
-        }
+        if (refusal)
+            return refuseTurn(deps, res, session, refusal, usageStartedAt);
         const pending = await deps.store.consumePendingResume(session.id);
         if (!pending) {
             return sendJson(res, 409, {
@@ -242,6 +252,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' });
@@ -249,10 +260,8 @@ export async function handleAssistantTurn(req, res, deps) {
         // Admission before any metered work (ADR 0201 §8): ahead of the deployment read and well ahead
         // of the model, so a refused turn costs the customer nothing.
         const refusal = await refusePublicTurn(deps, session, message, addressBucket);
-        if (refusal) {
-            captureAssistantUsage(deps.captureRequestEvent, assistantRefusedTurnUsageRequestEvent(session, refusal.code, performance.now() - usageStartedAt));
-            return sendJson(res, refusal.status, { error: refusal.message, code: refusal.code });
-        }
+        if (refusal)
+            return refuseTurn(deps, res, session, refusal, usageStartedAt);
         // The visitor typed first: any pending post-sign-in resume is moot, and must not fire later.
         if (session.pendingResume)
             await deps.store.consumePendingResume(session.id);
@@ -296,7 +305,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 +384,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/service/package.json

@@ -39,7 +39,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.87.1",
+    "@noodle-borg/agent-kit": "0.88.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

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

@@ -77,6 +77,7 @@ export function emitRequestEvent(input) {
         ...(clientVersion !== undefined ? { clientVersion } : {}),
         clientFamily: family,
         ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
+        surface: 'mcp',
         subjectKind: subject !== undefined ? 'authenticated' : 'anonymous',
         method,
         kind: DISCOVERY_METHODS.has(method) ? 'discovery' : 'usage',
@@ -147,6 +148,7 @@ export function emitDeniedRequestEvent(input) {
         sessionSource: 'none',
         clientFamily: clientFamily(undefined, header(req, 'user-agent')),
         ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
+        surface: 'mcp',
         subjectKind: 'anonymous',
         method,
         kind: 'usage',

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.28.0",
+  "version": "1.29.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.1",
+  "version": "0.149.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",
@@ -236,7 +236,7 @@
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/server": "2.0.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.87.1",
+    "@noodle-borg/agent-kit": "0.88.0",
     "@noodle-borg/app-audit": "0.0.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",