@noodleseed/one 0.141.2 → 0.142.0

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

@@ -1,12 +1,10 @@
 import { ADMISSION_DEFAULTS } from '@noodle-borg/admission-limits/portable';
 import { requestModelCompletion, } from '@noodle-borg/assistant-gateway/model-runtime';
-import { assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, authenticatedSurfaceOf, dispatchAssistantTool, projectAssistantGuide, publicSurfaceOf, selectAssistantModelTools, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { assistantModelToolOncePerSession, assistantModelToolRequiredWhenVisible, assistantViewAvailableData, authenticatedSurfaceOf, dispatchAssistantTool, projectAssistantGuide, publicSurfaceOf, selectAssistantModelTools, toolTouchesDelegatedAuth, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
 import { guardedFetch } from '@noodle-borg/connector-http';
 import { evaluateToolAuthorization } from '@noodle-borg/protocol';
 import { executeTool } from '@noodle-borg/runtime';
-import { toolTouchesDelegatedAuth } from '../assistant-delegated-projection.js';
-import { assistantViewAvailableData } from '../assistant-view-availability.js';
 import { invocationContextSystemMessages } from '../invocation-context.js';
 import { interceptForElevation, offersSignIn } from './assistant-elevation.js';
 import { assistantKnowledgeModelTools, executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, KNOWLEDGE_CITATION_GUIDANCE, resolveAssistantKnowledge, } from './assistant-knowledge.js';

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

@@ -0,0 +1,104 @@
+import { assistantAppearanceOverrideSchema, assistantBrowserConfiguration, resolveAssistantAppearanceConfiguration, } from '@noodle-borg/assistant-gateway/portable';
+import { readJsonBody, sendForbidden, sendJson } from '../http-util.js';
+import { now } from './assistant-route-http.js';
+import { authorizeControlPlane } from './control-plane.js';
+export async function handleAssistantAppearance(req, res, tenant, deps) {
+    const store = deps.appearance;
+    if (store === undefined)
+        return sendJson(res, 503, { error: 'assistant appearance is unavailable' });
+    const identity = await authorizeControlPlane(req, res, deps.gate, { requireIdentity: false });
+    if (identity === false)
+        return;
+    if (identity && !identity.superAdmin) {
+        const member = await deps.controlPlane.isOrgMember({
+            org: tenant.org,
+            subject: identity.subject,
+        });
+        if (!member)
+            return sendForbidden(res, 'forbidden');
+    }
+    if (req.method === 'GET')
+        return respond(res, tenant, deps);
+    const expectedRevision = parseExpectedRevision(req.headers['if-match']);
+    if (expectedRevision === undefined) {
+        return sendJson(res, req.headers['if-match'] === undefined ? 428 : 400, {
+            error: req.headers['if-match'] === undefined ? 'If-Match is required' : 'invalid If-Match',
+        });
+    }
+    let override;
+    if (req.method === 'PUT') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = assistantAppearanceOverrideSchema.safeParse(body.value);
+        if (!parsed.success)
+            return sendJson(res, 400, { error: 'invalid assistant appearance' });
+        override = parsed.data;
+    }
+    else if (req.method !== 'DELETE') {
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const updated = await store.replace({
+        tenant,
+        expectedRevision,
+        override,
+        updatedAt: now(deps),
+        updatedBy: identity?.subject ?? 'local-operator',
+    });
+    if (!updated.ok) {
+        return sendJson(res, 409, {
+            error: 'assistant appearance revision conflict',
+            currentRevision: updated.currentRevision,
+        });
+    }
+    const target = await deps.registry.getActiveByTenant(tenant);
+    await deps.audit.emit({
+        eventType: updated.record.override === undefined
+            ? 'assistant.appearance.reset'
+            : 'assistant.appearance.updated',
+        org: tenant.org,
+        app: tenant.app,
+        env: tenant.env,
+        ...(target?.deploymentId ? { deploymentId: target.deploymentId } : {}),
+        decision: 'allow',
+        status: 200,
+        ...(identity ? { actorSubject: identity.subject } : {}),
+        ...(identity?.email ? { actorEmail: identity.email } : {}),
+        details: {
+            revision: updated.record.revision,
+            hasOverride: updated.record.override !== undefined,
+        },
+    });
+    return respond(res, tenant, deps, updated.record, target);
+}
+async function respond(res, tenant, deps, knownRecord, knownTarget) {
+    const target = knownTarget ?? (await deps.registry.getActiveByTenant(tenant));
+    const developer = target
+        ? assistantBrowserConfiguration(target.served.artifact.server)
+        : undefined;
+    const record = knownRecord ?? (await deps.appearance?.get(tenant));
+    const resolution = resolveAssistantAppearanceConfiguration(developer, record?.override);
+    const revision = record?.revision ?? 0;
+    res.setHeader('etag', `"${revision}"`);
+    return sendJson(res, 200, {
+        ok: true,
+        assistantEnabled: target?.served.artifact.server.assistant !== undefined,
+        revision,
+        fallback: resolution.fallback,
+        developer: developer ?? null,
+        override: record?.override ?? null,
+        effective: resolution.effective ?? null,
+        provenance: resolution.provenance,
+        ...(record ? { updatedAt: record.updatedAt.toISOString(), updatedBy: record.updatedBy } : {}),
+    });
+}
+function parseExpectedRevision(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const match = /^"(0|[1-9][0-9]*)"$/.exec(value);
+    if (!match?.[1])
+        return undefined;
+    const revision = Number(match[1]);
+    return Number.isSafeInteger(revision) ? revision : undefined;
+}
+//# sourceMappingURL=assistant-appearance.js.map

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

@@ -1,9 +1,11 @@
 import { handleAssistantAppRequest, handleAssistantPreflight, handleAssistantSession, handleAssistantTurn, handleConsoleApprovalNonce, } from './assistant.js';
+import { handleAssistantAppearance } from './assistant-appearance.js';
 import { handleAssistantClients } from './assistant-clients.js';
 import { handleAssistantDoctor } from './assistant-doctor.js';
 import { handleAssistantEmbedScript } from './assistant-embed-script.js';
 import { handleAssistantEmbeds } from './assistant-embeds.js';
 import { handleAssistantConfirmation, handleAssistantInteraction, } from './assistant-interactions.js';
+import { handlePublicAssistantConfiguration } from './assistant-public-configuration.js';
 import { handlePublicAssistantSession } from './assistant-public-session.js';
 import { handleAssistantSandbox } from './assistant-sandbox.js';
 import { handleAssistantTranscript } from './assistant-transcript.js';
@@ -41,6 +43,18 @@ export function dispatchAssistantRoutes(req, res, url, deps) {
     if (url.pathname === '/v1/assistant/public-sessions' && req.method === 'POST') {
         return run(req, res, deps, () => handlePublicAssistantSession(req, res, deps));
     }
+    const publicConfigurationMatch = /^\/v1\/assistant\/public-configurations\/([^/]+)$/.exec(url.pathname);
+    if (publicConfigurationMatch) {
+        let embedId;
+        try {
+            embedId = decodeURIComponent(publicConfigurationMatch[1] ?? '');
+        }
+        catch {
+            deps.sendJson(res, 400, { error: 'invalid embed id' });
+            return true;
+        }
+        return run(req, res, deps, () => handlePublicAssistantConfiguration(req, res, embedId, deps));
+    }
     if (url.pathname === '/v1/assistant/sessions' && req.method === 'POST') {
         return run(req, res, deps, () => handleAssistantSession(req, res, deps));
     }
@@ -54,6 +68,15 @@ export function dispatchAssistantRoutes(req, res, url, deps) {
         return run(req, res, deps, () => handleAssistantTranscript(req, res, deps));
     }
     const doctorMatch = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/assistant\/doctor$/.exec(url.pathname);
+    const appearanceMatch = /^\/v1\/orgs\/([^/]+)\/apps\/([^/]+)\/envs\/([^/]+)\/assistant\/appearance$/.exec(url.pathname);
+    if (appearanceMatch) {
+        const tenant = decodeTenant(appearanceMatch);
+        if (!tenant) {
+            deps.sendJson(res, 400, { error: 'invalid tenant path' });
+            return true;
+        }
+        return run(req, res, deps, () => handleAssistantAppearance(req, res, tenant, deps));
+    }
     if (doctorMatch) {
         const tenant = decodeTenant(doctorMatch);
         if (!tenant) {

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

@@ -1,5 +1,4 @@
-import { assistantInteractionTool, auditAssistantInteraction, } from '@noodle-borg/assistant-gateway/portable';
-import { assistantViewAvailableData } from '../assistant-view-availability.js';
+import { assistantInteractionTool, assistantViewAvailableData, auditAssistantInteraction, } from '@noodle-borg/assistant-gateway/portable';
 import { sendJson } from '../http-util.js';
 import { now } from './assistant.js';
 import { assistantInteractionScope } from './assistant-interaction-resolution.js';

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

@@ -1,6 +1,5 @@
-import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, auditAssistantInteraction, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { AssistantInteractionCapacityError, assistantConfirmationReview, assistantConfirmationTransition, assistantInputTransition, assistantInteractionTool, assistantPreparedArgumentReview, assistantPreparedToolContinuation, assistantSafeOutput, assistantToolContinuation, assistantViewAvailableData, auditAssistantInteraction, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
 import { executePreparedTool, executeToolInteractive, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
-import { assistantViewAvailableData } from '../assistant-view-availability.js';
 import { readJsonBody, sendJson } from '../http-util.js';
 import { applyBrowserCors, authenticateSession, now, } from './assistant.js';
 import { replayOrConflict, writeUnknownOutcome } from './assistant-interaction-replay.js';

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

@@ -0,0 +1,41 @@
+import { authorizePublicConfiguration, effectiveAssistantBrowserConfiguration, publicEmbedTenant, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
+import { sendJson } from '../http-util.js';
+import { applyBrowserCors } from './assistant-route-http.js';
+/** Browser-safe first paint for a public launcher; never mints a session or spends admission. */
+export async function handlePublicAssistantConfiguration(req, res, embedId, deps) {
+    if (req.method !== 'GET')
+        return sendJson(res, 405, { error: 'method not allowed' });
+    if (deps.publicEmbeds === undefined) {
+        return sendJson(res, 503, { error: 'public assistant surfaces are not enabled' });
+    }
+    const origin = typeof req.headers.origin === 'string' ? req.headers.origin : undefined;
+    const state = {};
+    const authorized = await authorizePublicConfiguration({ embedId, origin }, {
+        embeds: deps.publicEmbeds,
+        resolveActiveSurface: async (embed) => {
+            state.target = await deps.registry.getActiveByTenant(publicEmbedTenant(embed));
+            return state.target
+                ? publicSurfaceOf(state.target.served.artifact.server.assistant)
+                : undefined;
+        },
+    });
+    if (!authorized.ok) {
+        return sendJson(res, authorized.status, {
+            error: authorized.message,
+            code: authorized.code,
+        });
+    }
+    const target = state.target;
+    if (target === undefined) {
+        return sendJson(res, 409, { error: 'assistant deployment is unavailable' });
+    }
+    const resolved = await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(authorized.embed), deps.appearance);
+    applyBrowserCors(req, res, origin);
+    res.setHeader('cache-control', 'private, no-cache');
+    return sendJson(res, 200, {
+        ...(resolved.effective ? { configuration: resolved.effective } : {}),
+        fallback: resolved.fallback,
+        revision: resolved.record?.revision ?? 0,
+    });
+}
+//# sourceMappingURL=assistant-public-configuration.js.map

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

@@ -1,10 +1,9 @@
 import { randomBytes } from 'node:crypto';
 import { ADMISSION_DEFAULTS, clientAddressBucket } from '@noodle-borg/admission-limits/portable';
-import { mintPublicSession, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
+import { effectiveAssistantBrowserConfiguration, mintPublicSession, publicEmbedTenant, publicSurfaceOf, } from '@noodle-borg/assistant-gateway/portable';
 import { assistantSessionUsageRequestEvent, captureAssistantUsage, } from '@noodle-borg/observability';
 import { assistantSessionResponseSchema } from '@noodle-borg/wire-contracts';
 import { readJsonBody, sendJson } from '../http-util.js';
-import { assistantBrowserConfiguration } from './assistant-configuration.js';
 import { applyBrowserCors, assistantSessionEndpoints, now } from './assistant-route-http.js';
 /**
  * The transport half of anonymous session minting. Every decision — which refusal, in which order, and
@@ -16,10 +15,6 @@ import { applyBrowserCors, assistantSessionEndpoints, now } from './assistant-ro
  * echoes the validated origin, and a refusal echoes nothing, so a page that is not on the allowlist
  * fails visibly instead of quietly receiving a usable token.
  */
-/** The embed record stores the tenant flat; the registry and session store want it shaped. */
-function tenantOf(embed) {
-    return { org: embed.org, app: embed.app, env: embed.env };
-}
 export async function handlePublicAssistantSession(req, res, deps) {
     const usageStartedAt = performance.now();
     const embeds = deps.publicEmbeds;
@@ -45,12 +40,12 @@ export async function handlePublicAssistantSession(req, res, deps) {
         embeds,
         counters,
         resolveActiveSurface: async (embed) => {
-            const target = await deps.registry.getActiveByTenant(tenantOf(embed));
+            const target = await deps.registry.getActiveByTenant(publicEmbedTenant(embed));
             if (!target?.deploymentId)
                 return undefined;
             if (target.served.artifact.server.assistant?.model.kind === 'noodle-managed') {
                 sponsoredBudget = (await deps.managedModelResolver?.resolve({
-                    tenant: tenantOf(embed),
+                    tenant: publicEmbedTenant(embed),
                     deploymentId: target.deploymentId,
                 }))?.publicAdmission;
             }
@@ -60,16 +55,16 @@ export async function handlePublicAssistantSession(req, res, deps) {
         },
         resolveBudgetBounds: async () => sponsoredBudget,
         createSession: async (input) => {
-            const target = await deps.registry.getActiveByTenant(tenantOf(input.embed));
+            const target = await deps.registry.getActiveByTenant(publicEmbedTenant(input.embed));
             if (!target?.deploymentId)
                 throw new Error('assistant deployment vanished mid-mint');
             const current = now(deps);
-            configuration = assistantBrowserConfiguration(target.served.artifact.server);
+            configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, publicEmbedTenant(input.embed), deps.appearance)).effective;
             const created = await deps.store.createSession({
                 // A public surface has no client credential, so the embed id stands in as the minting
                 // authority. It is not a secret and nothing downstream may begin treating it as one.
                 clientId: input.embed.embedId,
-                tenant: tenantOf(input.embed),
+                tenant: publicEmbedTenant(input.embed),
                 deploymentId: target.deploymentId,
                 modelSource: target.served.artifact.server.assistant?.model.kind === 'noodle-managed'
                     ? 'noodle-managed'

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

@@ -1,5 +1,5 @@
 import { clientAddressBucket, } from '@noodle-borg/admission-limits/portable';
-import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, parseAssistantContextPreferences, parseAssistantCustomerRouting, resumeTurnMessage, resumeUnavailableMessage, shouldAutoResume, surfaceBindingForOrigin, withAssistantSessionExecutionAuthority, } from '@noodle-borg/assistant-gateway/portable';
+import { ASSISTANT_SESSION_IDLE_MS, dispatchAssistantTool, effectiveAssistantBrowserConfiguration, parseAssistantContextPreferences, parseAssistantCustomerRouting, 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';
@@ -10,7 +10,6 @@ import { assistantMessageTurnRequestSchema, assistantResumeTurnRequestSchema, as
 import { readJsonBody, sendForbidden, sendJson, sendUnauthorized } from '../http-util.js';
 import { resolveInvocationContextSnapshot } from '../invocation-context.js';
 import { createAssistantTurnStats, runAgentTurn } from './assistant-agent.js';
-import { assistantBrowserConfiguration } from './assistant-configuration.js';
 import { elevateAssistantSession } from './assistant-elevation.js';
 import { executeAssistantKnowledgeSearch, findAssistantKnowledgeComponent, resolveAssistantKnowledge, } from './assistant-knowledge.js';
 import { refusePublicTurn } from './assistant-public-turn.js';
@@ -100,7 +99,7 @@ export async function handleAssistantSession(req, res, deps) {
     const declaredClaims = assistant.sessionClaims ?? {};
     const claims = Object.fromEntries(Object.entries(isVerifiedClaims(parsed.claims) ? parsed.claims : {}).filter(([key]) => key in declaredClaims));
     const current = now(deps);
-    const configuration = assistantBrowserConfiguration(target.served.artifact.server);
+    const configuration = (await effectiveAssistantBrowserConfiguration(target.served.artifact.server, client.tenant, deps.appearance)).effective;
     const roles = canonicalizeAuthorizationClaimValues(parsed.user.roles, 'role');
     const scopes = canonicalizeAuthorizationClaimValues(parsed.user.scopes, 'scope');
     // Hoisted so an elevation and a fresh exchange bind the *same* principal. Two constructions would be

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

@@ -1,4 +1,4 @@
-import { InMemoryAssistantStore } from '@noodle-borg/assistant-gateway/portable';
+import { InMemoryAssistantAppearanceSettingsStore, InMemoryAssistantStore, } from '@noodle-borg/assistant-gateway/portable';
 import { allowAllGate, InMemoryControlPlaneStore } from '@noodle-borg/control-plane/portable';
 import { dispatchKnowledgeRequest } from '@noodle-borg/knowledge-operations/portable';
 import { OPENAI_APPS_CHALLENGE_PATH } from '@noodle-borg/module';
@@ -59,6 +59,7 @@ export function createServiceHandler(registry, options = {}) {
     const alertRuleStore = options.alertRuleStore ?? new InMemoryAlertRuleStore();
     const [intentSettings, intentEvents, requestEvents, intentPreviewOrgs] = createObservabilityStores(options);
     const assistantStore = options.assistantStore ?? new InMemoryAssistantStore();
+    const assistantAppearance = options.assistantAppearance ?? new InMemoryAssistantAppearanceSettingsStore();
     const anonymousLimiter = new AnonymousConsumerLimiter();
     registry.setPlatformConnectors({ catalog: [BUILTIN_STATE_CATALOG_CONNECTOR], connectors: [] });
     const moduleProviders = createServiceModuleProviders({
@@ -237,6 +238,7 @@ export function createServiceHandler(registry, options = {}) {
         if (dispatchAssistantRoutes(req, res, url, {
             registry,
             store: assistantStore,
+            appearance: assistantAppearance,
             ...(options.publicEmbeds !== undefined ? { publicEmbeds: options.publicEmbeds } : {}),
             ...(options.elevations !== undefined ? { elevations: options.elevations } : {}),
             ...(options.admissionCounters !== undefined

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

@@ -6,10 +6,10 @@ The package exports the canonical `<noodle-assistant>` managed Web Component, th
 `<noodle-app-view>` MCP App host from `@noodleseed/assistant/app-view`, a managed React wrapper and
 `NoodleAppView` adapter from `@noodleseed/assistant/react`, a renderer-free React hook from
 `@noodleseed/assistant/react/client`, a DOM-free client from `@noodleseed/assistant/client`, and the
-backend-only `createAssistantSession` helper from `@noodleseed/assistant/server`. Light, dark, and automatic
-themes work without configuration; the component inherits the deployed MCP server's brand kit while slots,
-methods, events, and semantic CSS variables let a SaaS developer integrate it without depending on internal
-DOM selectors.
+backend-only `createAssistantSession` helper from `@noodleseed/assistant/server`. The component inherits the
+deployed MCP server's brand kit while slots, methods, events, and semantic CSS variables let a SaaS developer
+integrate it without depending on internal DOM selectors. Light, dark, automatic host-page matching, and
+host-page inversion work without replacing conversation or App DOM.
 
 Never pass an embed client secret, model key, MCP token, or raw application session into the browser
 component. Exchange the already-authenticated user from the customer backend and return only the short-lived
@@ -22,7 +22,7 @@ The model configuration and SaaS integration credentials have different owners:
 | Noodle deployment | `ASSISTANT_MODEL_BASE_URL`, `ASSISTANT_MODEL`, `ASSISTANT_MODEL_API_KEY`             | Managed with `noodle variables set` / `noodle secrets set` |
 | Customer backend  | `NOODLE_SERVICE_URL`, `NOODLE_ASSISTANT_CLIENT_ID`, `NOODLE_ASSISTANT_CLIENT_SECRET` | Backend environment or secret manager only                 |
 
-`allowedOrigins` accepts exact origins. Production origins must be HTTPS; plain HTTP is accepted only for
+`access.origins` accepts exact origins. Production origins must be HTTPS; plain HTTP is accepted only for
 loopback development origins such as `http://localhost:3000`. Local MCP authoring remains available without
 login, but an external browser embed needs an active deployment before its deployment-bound client can be
 created.
@@ -55,6 +55,7 @@ structure and treatment in `embeddedAssistant({ presentation })`:
 
 ```ts
 import {
+  authenticatedWebsite,
   embeddedAssistant,
   openAICompatible,
   secret,
@@ -83,19 +84,23 @@ export default server(
         model: variable("ASSISTANT_MODEL"),
         apiKey: secret("ASSISTANT_MODEL_API_KEY"),
       }),
-      allowedOrigins: ["http://localhost:3000", "https://app.acme.example"],
+      access: authenticatedWebsite({
+        origins: ["http://localhost:3000", "https://app.acme.example"],
+      }),
       layout: {
         mode: "floating",
-        position: "bottom-right",
-        panelWidth: 520,
+        position: "bottom-center",
+        panelWidth: 970,
         panelMinHeight: 540,
-        panelMaxHeight: 740,
-        edgeOffset: 24,
+        panelMaxHeight: 1025,
+        edgeOffset: 20,
       },
-      behavior: { showTimestamps: true },
+      theme: "invert",
+      behavior: { showTimestamps: true, showPoweredBy: false },
       labels: {
         welcomeHeading: "How can Acme help?",
         welcomeMessage: "Fast answers from the tools your team already uses.",
+        launcherPlaceholder: "Ask Acme anything",
         composerPlaceholder: "Message Acme Support…",
         sessionReady: "Acme support is online",
       },
@@ -107,6 +112,7 @@ export default server(
           radius: 20,
         },
         launcher: {
+          style: "bubble",
           icon: "chat",
           size: "lg",
           status: "session",
@@ -144,10 +150,15 @@ markup-looking text stays text. `presentation.panel.radius` is a bounded panel-s
 not a second color or identity source. An HTTPS or packaged SVG referenced by `branding.logo`, `branding.mark`, or
 `branding.avatar` is a bounded asset, not inline renderer markup.
 
-If `presentation` is omitted, the rounded Halo-inspired baseline remains: a frosted glass panel with a 24px
-radius, soft elevation, subtle border/motion, medium brand-mark launcher without status or effect,
-undecorated header, pill composer and action controls, and rounded user bubbles with plain assistant messages
-at comfortable width. Partial objects merge with those defaults.
+With UI overrides omitted, the complete managed baseline remains: a bottom-center frosted launcher pill that
+morphs into a prompt input before opening; a 970px outer desktop shell with 20px side padding, 85vh height,
+1025px maximum height, and a 24px panel using the built-in `#F8F8F8` light and `#0C0A09` dark surfaces;
+bottom prompt chips and pill composer; plain assistant messages and 85%-wide user bubbles; a Noodle Seed
+attribution row; and safe-area-aware mobile fullscreen.
+The generic prompt chips ship as defaults, while an authored list—including `[]`—replaces them. Set
+`presentation.launcher.style` to `bubble` for a direct-open 44px launcher. The baseline does not include the
+“Available on ChatGPT” promotion. Partial configuration objects merge with the remaining defaults;
+`presentation.panel.surface: "glass"` remains available when a translucent panel is intentional.
 
 ### Configure and deploy
 
@@ -294,6 +305,22 @@ import "@noodleseed/assistant";
 ></noodle-assistant>
 ```
 
+That single element is the complete managed assistant in React, Vue, Angular, or plain DOM. The
+default pill expands into a prompt first; set `presentation.launcher.style: "bubble"` in `server.ts` when the
+launcher should open the panel directly. Frameworks must treat `noodle-assistant` as a custom element.
+
+When the host needs an authenticated fetch wrapper, assign complex values as properties before connecting
+the element so the first session exchange already carries the application's credentials:
+
+```ts
+import type { NoodleAssistantElement } from "@noodleseed/assistant";
+
+const assistant = document.createElement("noodle-assistant") as NoodleAssistantElement;
+assistant.fetch = authenticatedFetch;
+assistant.sessionEndpoint = "/api/assistant/session";
+document.body.append(assistant);
+```
+
 Or use React:
 
 ```tsx
@@ -641,24 +668,31 @@ noodle-assistant {
 ```
 
 For each matching region or token, precedence is the typed host appearance object, then host-provided slot
-content or a public CSS custom property, then compiled server `presentation`/`branding`, then built-in
-defaults. The public slots are `launcher-icon`,
+content or a public CSS custom property, then the saved environment operator override, compiled server
+`presentation`/`branding`, and built-in defaults. The public slots are `launcher-icon`,
 `header-leading`, `header-actions`, `empty-state`, `composer-leading`, `composer-trailing`, and
 `conversation-footer`; slotted host DOM replaces the renderer fallback for that region. Slots are a trusted
 embedding-page integration API, not a way to put HTML or callbacks in deployment configuration. Internal
 shadow-DOM selectors and classes are not public API.
 
-`theme="auto"` follows the browser's operating-system color preference. When the embedding application has
+The Console **Assistant** tab and `noodle assistant appearance show|apply|reset` manage that environment
+override. Existing embed code does not change: public elements load its non-secret configuration before
+first paint without spending a session mint, while authenticated elements receive it from session exchange.
+Each new session pins one resolved revision; an open conversation remains visually stable.
+
+`theme="auto"` follows an explicit `light`/`dark` host-page class or data attribute, then the browser's
+operating-system preference; `theme="invert"` selects the opposite host mode. When the embedding application has
 its own theme toggle, pass its resolved `"light"` or `"dark"` value to `NoodleAssistant` and every
 `<noodle-app-view>`/`NoodleAppView`. Updates change the assistant in place and notify mounted MCP Apps through standard host
 context.
 
 Server branding controls customer name, themed logo/mark/avatar assets, semantic light/dark colors, density,
-radius, typography, and automatic theme. `embeddedAssistant(...)` controls floating/inline/drawer layout,
-position and dimensions, mobile and launcher/header/avatar/timestamp behavior, visible labels, suggested
+radius, typography, and automatic theme. `embeddedAssistant(...)` controls theme selection,
+floating/inline/drawer layout, position and dimensions, mobile and launcher/header/avatar/timestamp/attribution behavior, visible labels, suggested
 prompts, privacy/terms links, locale, and text direction.
 Named slots cover launcher/header/composer/footer extensions. Public methods include `open`, `close`,
 `toggle`, `focusComposer`, `sendMessage`, `stop`, `reconnect`, `updateContext`, `updateModelContext`, `respond`, `confirmTool`, and `resetSession`;
+lifecycle properties include `sessionEndpoint`, `embedId`, `serviceUrl`, `fetch`, and `appearance`;
 lifecycle, message, tool-proposal, interaction-resolution, view-availability, context, and error events
 support application integration. `confirmTool(id)` remains the compatibility shorthand for
 `respond(id, { action: 'accept' })`.

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

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/assistant",
-  "version": "1.25.0",
+  "version": "1.25.1",
   "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.141.2",
+  "version": "0.142.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",