@noodleseed/one 0.137.0 → 0.138.0

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

@@ -0,0 +1,37 @@
+import { readModelCompletion } from './model-stream.js';
+export async function requestModelCompletion(input) {
+    const { binding } = input;
+    const url = new URL(`${binding.baseUrl.replace(/\/$/, '')}/chat/completions`);
+    if (url.protocol !== 'https:' || url.username || url.password) {
+        throw new Error('unsafe model endpoint');
+    }
+    const completionLimit = input.maxCompletionTokens ?? binding.requestPolicy?.maxCompletionTokens;
+    const body = JSON.stringify({
+        ...binding.requestPolicy?.extraBody,
+        model: binding.model,
+        stream: true,
+        messages: input.messages,
+        tools: input.tools,
+        ...(completionLimit === undefined ? {} : { max_completion_tokens: completionLimit }),
+    });
+    const requestBytes = new TextEncoder().encode(body).byteLength;
+    const maxRequestBytes = binding.requestPolicy?.maxRequestBytes;
+    if (maxRequestBytes !== undefined && requestBytes > maxRequestBytes) {
+        throw new Error('model request too large');
+    }
+    const bearerToken = binding.apiKey ?? (await binding.bearerToken());
+    if (!/^[^\s]{1,8192}$/.test(bearerToken))
+        throw new Error('invalid model bearer token');
+    const timeoutSignal = AbortSignal.timeout(binding.requestPolicy?.timeoutMs ?? 30_000);
+    const response = await input.fetcher(url.href, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${bearerToken}`, 'content-type': 'application/json' },
+        body,
+        redirect: 'manual',
+        signal: input.signal === undefined ? timeoutSignal : AbortSignal.any([input.signal, timeoutSignal]),
+    });
+    if (!response.ok)
+        throw new Error(`model request failed (${response.status})`);
+    return readModelCompletion(response, input.onContent ?? (() => undefined), input.maxResponseBytes);
+}
+//# sourceMappingURL=model-request.js.map

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

@@ -0,0 +1,4 @@
+/** Provider-neutral embedded-assistant model transport. */
+export * from './model-request.js';
+export * from './model-stream.js';
+//# sourceMappingURL=model-runtime.js.map

package/node_modules/@noodle-borg/{service/dist/assistant-model-stream.js → assistant-gateway/dist/model-stream.js}

@@ -2,7 +2,11 @@ export async function readModelCompletion(response, onContent, maxBytes = 1 << 2
     const contentType = response.headers.get('content-type') ?? '';
     if (!contentType.includes('text/event-stream')) {
         const text = await readBoundedText(response, maxBytes);
-        const completion = JSON.parse(text);
+        const parsed = JSON.parse(text);
+        const completion = {
+            choices: parsed.choices,
+            ...normalizeUsage(parsed.usage),
+        };
         const message = completion.choices[0]?.message;
         if (!message?.tool_calls?.length && message?.content)
             onContent(message.content);
@@ -15,6 +19,7 @@ export async function readModelCompletion(response, onContent, maxBytes = 1 << 2
     const toolCalls = new Map();
     let pending = '';
     let content = '';
+    let usage;
     let bytes = 0;
     while (true) {
         const { done, value } = await reader.read();
@@ -36,6 +41,7 @@ export async function readModelCompletion(response, onContent, maxBytes = 1 << 2
             const parsed = JSON.parse(data);
             if (parsed.error !== undefined)
                 throw new Error('model stream returned an error');
+            usage = normalizeUsageValue(parsed.usage) ?? usage;
             const delta = parsed.choices?.[0]?.delta;
             if (delta?.content) {
                 content += delta.content;
@@ -80,8 +86,34 @@ export async function readModelCompletion(response, onContent, maxBytes = 1 << 2
                 },
             },
         ],
+        ...(usage === undefined ? {} : { usage }),
     };
 }
+function normalizeUsage(usage) {
+    const normalized = normalizeUsageValue(usage);
+    return normalized === undefined ? {} : { usage: normalized };
+}
+function normalizeUsageValue(usage) {
+    if (usage === undefined)
+        return undefined;
+    const promptTokens = nonNegativeInteger(usage.prompt_tokens);
+    const completionTokens = nonNegativeInteger(usage.completion_tokens);
+    const reportedTotalTokens = nonNegativeInteger(usage.total_tokens);
+    if (promptTokens === undefined || completionTokens === undefined) {
+        return undefined;
+    }
+    const totalTokens = reportedTotalTokens ?? promptTokens + completionTokens;
+    const reasoningTokens = nonNegativeInteger(usage.completion_tokens_details?.reasoning_tokens);
+    return {
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
+    };
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
 async function readBoundedText(response, maxBytes) {
     const text = await response.text();
     if (new TextEncoder().encode(text).byteLength > maxBytes) {
@@ -89,4 +121,4 @@ async function readBoundedText(response, maxBytes) {
     }
     return text;
 }
-//# sourceMappingURL=assistant-model-stream.js.map
+//# sourceMappingURL=model-stream.js.map

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

@@ -1,6 +1,7 @@
 import type { AdmissionEnvelope, DailyCounterStore } from '@noodle-borg/admission-limits/portable';
 import { type PublicEmbedRecord, type PublicEmbedStore } from './embed-store.js';
 import type { PublicSurface } from './public-surface.js';
+import { type SurfaceBudgetBounds } from './surface-budget.js';
 /**
  * Minting an anonymous session for a public page.
  *
@@ -17,6 +18,8 @@ export interface PublicSessionPorts {
     readonly counters: DailyCounterStore;
     /** The live surface for this tenant, read from the *active* deployment at mint time. */
     resolveActiveSurface(embed: PublicEmbedRecord): Promise<PublicSurface | undefined>;
+    /** Optional hosted entitlement; absent preserves the ordinary customer-funded envelope. */
+    readonly resolveBudgetBounds?: (embed: PublicEmbedRecord) => Promise<SurfaceBudgetBounds | undefined>;
     /** Persist the anonymous session and return its bearer token and expiry. */
     createSession(input: {
         readonly embed: PublicEmbedRecord;

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

@@ -30,7 +30,8 @@ export async function mintPublicSession(request, envelope, ports) {
     }
     // The surface's own budget, which an operator may have lowered — or set to zero, which is the kill
     // switch. Resolved after the embed is known and before anything is spent.
-    const surfaceLimits = surfaceEnvelope(envelope, embed);
+    const budgetBounds = await ports.resolveBudgetBounds?.(embed);
+    const surfaceLimits = surfaceEnvelope(envelope, embed, budgetBounds);
     const now = ports.now();
     // Fairness before solvency: an address at its hourly ceiling is refused without spending any of the
     // surface's day, so one visitor cannot burn the customer's budget on refusals.

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

@@ -1,6 +1,7 @@
 import type { AdmissionEnvelope, DailyCounterStore } from '@noodle-borg/admission-limits/portable';
 import type { AssistantTurnConsumption } from './assistant-store.js';
-import type { PublicEmbedStore } from './embed-store.js';
+import type { PublicEmbedRecord, PublicEmbedStore } from './embed-store.js';
+import { type SurfaceBudgetBounds } from './surface-budget.js';
 /**
  * Whether an anonymous visitor's next turn runs.
  *
@@ -16,6 +17,8 @@ export interface PublicTurnPorts {
     readonly counters: DailyCounterStore;
     /** Re-read per turn: it carries the operator's live budget, and whether the surface still exists. */
     readonly embeds: Pick<PublicEmbedStore, 'lookup'>;
+    /** Optional hosted entitlement; resolved live so cohort removal lowers the envelope immediately. */
+    readonly resolveBudgetBounds?: (embed: PublicEmbedRecord) => Promise<SurfaceBudgetBounds | undefined>;
     /** Spend one of this session's turns, atomically (admission tier 1). */
     consumeTurn(id: string, limit: number): Promise<AssistantTurnConsumption>;
     now(): Date;

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

@@ -22,7 +22,8 @@ export async function admitPublicTurn(request, defaults, ports) {
             message: 'assistant is unavailable right now',
         };
     }
-    const envelope = surfaceEnvelope(defaults, embed);
+    const budgetBounds = await ports.resolveBudgetBounds?.(embed);
+    const envelope = surfaceEnvelope(defaults, embed, budgetBounds);
     // Fairness before either of the budgets below: an address at its hourly ceiling is turned away
     // without spending the session's allowance or the customer's day, so one visitor cannot burn either
     // on turns that were never served. Mirrors the ordering the mint uses.

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

@@ -1,5 +1,10 @@
 import { type AdmissionEnvelope } from '@noodle-borg/admission-limits/portable';
 import type { PublicEmbedRecord } from './embed-store.js';
+/** Hosted/operator entitlement layered between structural maxima and per-surface overrides. */
+export interface SurfaceBudgetBounds {
+    readonly defaults: Pick<AdmissionEnvelope, 'turnsPerSession' | 'turnsPerDay' | 'mintsPerDay'>;
+    readonly ceiling: Pick<AdmissionEnvelope, 'turnsPerDay' | 'mintsPerDay'>;
+}
 /**
  * One surface's daily budget, resolved from the operator's override and the deployment's defaults.
  *
@@ -12,5 +17,5 @@ import type { PublicEmbedRecord } from './embed-store.js';
  * operator any more than by app code, so an over-eager `--turns-per-day 999999999` degrades to the
  * ceiling instead of becoming the ceiling. Zero survives clamping and is the kill switch.
  */
-export declare function surfaceEnvelope(base: AdmissionEnvelope, embed: Pick<PublicEmbedRecord, 'turnsPerDay' | 'mintsPerDay'>): AdmissionEnvelope;
+export declare function surfaceEnvelope(base: AdmissionEnvelope, embed: Pick<PublicEmbedRecord, 'turnsPerDay' | 'mintsPerDay'>, bounds?: SurfaceBudgetBounds): AdmissionEnvelope;
 //# sourceMappingURL=surface-budget.d.ts.map

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

@@ -11,13 +11,19 @@ import { clamp } from '@noodle-borg/admission-limits/portable';
  * operator any more than by app code, so an over-eager `--turns-per-day 999999999` degrades to the
  * ceiling instead of becoming the ceiling. Zero survives clamping and is the kill switch.
  */
-export function surfaceEnvelope(base, embed) {
-    if (embed.turnsPerDay === undefined && embed.mintsPerDay === undefined)
-        return base;
-    return clamp({
-        ...base,
+export function surfaceEnvelope(base, embed, bounds) {
+    const effectiveBase = bounds === undefined ? base : clamp({ ...base, ...bounds.defaults });
+    const requested = clamp({
+        ...effectiveBase,
         ...(embed.turnsPerDay !== undefined ? { turnsPerDay: embed.turnsPerDay } : {}),
         ...(embed.mintsPerDay !== undefined ? { mintsPerDay: embed.mintsPerDay } : {}),
     });
+    if (bounds === undefined)
+        return requested;
+    return {
+        ...requested,
+        turnsPerDay: Math.min(requested.turnsPerDay, bounds.ceiling.turnsPerDay),
+        mintsPerDay: Math.min(requested.mintsPerDay, bounds.ceiling.mintsPerDay),
+    };
 }
 //# sourceMappingURL=surface-budget.js.map

package/node_modules/@noodle-borg/assistant-gateway/package.json

@@ -17,6 +17,10 @@
       "types": "./dist/portable.d.ts",
       "import": "./dist/portable.js"
     },
+    "./model-runtime": {
+      "types": "./dist/model-runtime.d.ts",
+      "import": "./dist/model-runtime.js"
+    },
     "./postgres": {
       "types": "./dist/postgres.d.ts",
       "import": "./dist/postgres.js"
@@ -36,7 +40,7 @@
     "@noodle-borg/module": "0.0.0",
     "@noodle-borg/protocol": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
-    "@noodleseed/assistant": "1.22.0"
+    "@noodleseed/assistant": "1.23.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.1",

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

@@ -59,6 +59,7 @@ export interface AssistantLabels {
     readonly copy?: string;
     readonly newMessages?: string;
     readonly reconnect?: string;
+    readonly newConversation?: string;
     readonly retry?: string;
     readonly unavailable?: string;
     readonly sessionExpired?: string;
@@ -108,6 +109,11 @@ export interface OpenAICompatibleModel {
     /** Managed secret name, never the secret value. */
     readonly apiKey: string;
 }
+/** Provider-neutral request for the model selected and operated by Noodle Seed Cloud. */
+export interface NoodleManagedModel {
+    readonly kind: 'noodle-managed';
+}
+export type AssistantModel = OpenAICompatibleModel | NoodleManagedModel;
 /**
  * A verified session claim the embedding backend may pass at session exchange. Keys become
  * `${user.claims.<key>}` in tool fulfilment; `exposeToModel: true` additionally places the value
@@ -184,7 +190,7 @@ export interface PublicWebsiteInput {
 export declare function authenticatedWebsite(input: AuthenticatedWebsiteInput): AuthenticatedWebsiteAccess;
 export declare function publicWebsite(input: PublicWebsiteInput): PublicWebsiteAccess;
 export interface EmbeddedAssistantOptions extends AssistantUiOptions {
-    readonly model: OpenAICompatibleModel;
+    readonly model: AssistantModel;
     /** One surface, or every front door this assistant serves. */
     readonly access: AssistantAccess | readonly AssistantAccess[];
 }
@@ -197,7 +203,7 @@ export interface AssistantSurfaceConfig {
     readonly sessionClaims?: Readonly<Record<string, SessionClaimDeclaration>>;
 }
 export interface EmbeddedAssistantConfig extends AssistantUiOptions {
-    readonly model: OpenAICompatibleModel;
+    readonly model: AssistantModel;
     readonly surfaces: readonly AssistantSurfaceConfig[];
     /**
      * Union of every surface's origins. Kept at the top level so the service's origin check and the
@@ -208,5 +214,7 @@ export interface EmbeddedAssistantConfig extends AssistantUiOptions {
     readonly sessionClaims?: Readonly<Record<string, SessionClaimDeclaration>>;
 }
 export declare function openAICompatible(input: OpenAICompatibleModelInput): OpenAICompatibleModel;
+/** Use Noodle Seed Cloud's operator-selected model. Provider details never enter authored source. */
+export declare function noodleManaged(): NoodleManagedModel;
 export declare function embeddedAssistant(input: EmbeddedAssistantOptions): EmbeddedAssistantConfig;
 //# sourceMappingURL=assistant.d.ts.map

package/node_modules/@noodle-borg/authoring/dist/assistant.js

@@ -33,6 +33,10 @@ export function openAICompatible(input) {
         apiKey: serializeSecretRef(input.apiKey, 'assistant.model.apiKey'),
     };
 }
+/** Use Noodle Seed Cloud's operator-selected model. Provider details never enter authored source. */
+export function noodleManaged() {
+    return { kind: 'noodle-managed' };
+}
 export function embeddedAssistant(input) {
     const { model, access, suggestedPrompts, ...ui } = input;
     assertAccessDeclared(input, access);

package/node_modules/@noodle-borg/authoring/dist/index.d.ts

@@ -2,7 +2,7 @@ import type { ConnectorFile, HttpConnectorDef } from '@noodle-borg/connector-def
 import { z } from 'zod';
 export type { PackagedAssetReference } from '@noodle-borg/compiler';
 export type { AgentCapabilityKind, AgentCapabilityRef, AgentExampleSource, AgentGuideSource, AgentWorkflowSource, AgentWorkflowStepSource, } from './agent-guide.js';
-export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, type AuthenticatedWebsiteInput, authenticatedWebsite, type CapabilityRef, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, type OpenAICompatibleModel, type OpenAICompatibleModelInput, openAICompatible, type PublicWebsiteAccess, type PublicWebsiteInput, publicWebsite, } from './assistant.js';
+export { type AssistantAccess, type AssistantCapability, type AssistantLabels, type AssistantLayoutMode, type AssistantModel, type AssistantPosition, type AssistantPresentationOptions, type AssistantPresentationTone, type AssistantSurfaceConfig, type AssistantSurfaceMode, type AssistantThemeMode, type AssistantUiOptions, type AuthenticatedWebsiteAccess, type AuthenticatedWebsiteInput, authenticatedWebsite, type CapabilityRef, type EmbeddedAssistantConfig, type EmbeddedAssistantOptions, embeddedAssistant, type NoodleManagedModel, noodleManaged, type OpenAICompatibleModel, type OpenAICompatibleModelInput, openAICompatible, type PublicWebsiteAccess, type PublicWebsiteInput, publicWebsite, } from './assistant.js';
 export { type ConfigRef, type ConfigRefKind, secret, variable, } from './config.js';
 export { type BoundConnectorRef, bind, type ConnectionBinding, type ConnectionRef, type ConnectionSource, clientCredentials, connection, externalExchange, type GoogleWorkloadIdentityAccess, googleWorkloadIdentity, managedSecret, } from './connections.js';
 export { type ComputeHost, type ComputeLimits, type ComputeOperationOptions, ConnectorBuilder, type ConnectorCatalogDoc, type ConnectorOpDefinition, type ConnectorOperationOptions, type ConnectorRef, connector, type HttpConnectorOptions, } from './connectors.js';

package/node_modules/@noodle-borg/authoring/dist/index.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export { authenticatedWebsite, embeddedAssistant, openAICompatible, publicWebsite, } from './assistant.js';
+export { authenticatedWebsite, embeddedAssistant, noodleManaged, openAICompatible, publicWebsite, } from './assistant.js';
 export { secret, variable, } from './config.js';
 export { bind, clientCredentials, connection, externalExchange, googleWorkloadIdentity, managedSecret, } from './connections.js';
 export { ConnectorBuilder, connector, } from './connectors.js';

package/node_modules/@noodle-borg/authoring/dist/load-authored.js

@@ -33,7 +33,7 @@ export function prepareAuthoringRuntimeDir(dir, options) {
             './react': './react.mjs',
         },
     }));
-    writeFileSync(join(self, 'index.mjs'), "export { annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedSecret, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tool, variable, when, z } from '@noodle-borg/authoring';\n");
+    writeFileSync(join(self, 'index.mjs'), "export { annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedSecret, noodleManaged, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tool, variable, when, z } from '@noodle-borg/authoring';\n");
     writeFileSync(join(self, 'platform.mjs'), "export { noodlePlatform, noodlePlatformCatalog } from '@noodle-borg/authoring';\n");
     writeFileSync(join(self, 'react.mjs'), "export { generateHelpers } from '@noodle-borg/authoring/react';\n");
 }

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-assistant.js

@@ -203,6 +203,23 @@ export const ASSISTANT_COMMAND = {
         CLIENTS_SUBCOMMAND,
         EMBEDS_SUBCOMMAND,
         BUDGET_SUBCOMMAND,
+        subcommand({
+            ...SUBCOMMAND_FIELDS,
+            name: 'usage',
+            summary: 'Show assistant sessions, conversation depth, engagement, latency, and model tokens.',
+            flags: [
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'window',
+                    type: 'string',
+                    value: '<window>',
+                    summary: 'Aggregation window.',
+                    constraints: { choices: ['24h', '7d', '30d'], default: '7d' },
+                }),
+                ...TENANT_FLAGS,
+            ],
+            jsonOutput: { mode: 'single' },
+        }),
         subcommand({
             ...SUBCOMMAND_FIELDS,
             name: 'embed',

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-hosted-deployment.js

@@ -132,6 +132,13 @@ export const CATALOG_HOSTED_DEPLOYMENT = [
                 summary: 'Identity access mode for the deployment.',
                 constraints: { choices: ACCESS_MODES },
             }),
+            flag({
+                ...FLAG_FIELDS,
+                name: 'owner-subject',
+                type: 'string',
+                value: '<subject>',
+                summary: 'Exact OAuth subject bound when access is owner-only.',
+            }),
             flag({
                 ...FLAG_FIELDS,
                 name: 'connectors',
@@ -318,6 +325,13 @@ export const CATALOG_HOSTED_DEPLOYMENT = [
                         value: '<version>',
                         summary: 'Server version whose access mode is changed.',
                     }),
+                    flag({
+                        ...FLAG_FIELDS,
+                        name: 'owner-subject',
+                        type: 'string',
+                        value: '<subject>',
+                        summary: 'Exact OAuth subject to bind or transfer for owner-only access.',
+                    }),
                     ...TENANT_TARGET_FLAGS,
                 ],
                 jsonOutput: { mode: 'single' },

package/node_modules/@noodle-borg/compiler/dist/artifact/types.d.ts

@@ -227,13 +227,7 @@ export interface ArtifactServer {
     /** Compiled knowledge components (ADR 0202, Core v2): descriptors + generated tool metadata, never bytes. */
     readonly knowledge?: readonly CompiledKnowledgeComponent[];
     readonly assistant?: {
-        readonly model: {
-            readonly kind: 'openai-compatible';
-            readonly baseUrl: string;
-            readonly model: string;
-            /** Managed secret name, never the secret value. */
-            readonly apiKey: string;
-        };
+        readonly model: NonNullable<Manifest['server']['assistant']>['model'];
         readonly allowedOrigins: readonly string[];
     } & Omit<NonNullable<Manifest['server']['assistant']>, 'model' | 'allowedOrigins'>;
     readonly branding?: {

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -231,6 +231,7 @@ export declare const manifestV1Schema: z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -325,12 +326,14 @@ export declare const manifestV1Schema: z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{
@@ -682,6 +685,7 @@ export declare const manifestV2Schema: z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -776,12 +780,14 @@ export declare const manifestV2Schema: z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{
@@ -1343,6 +1349,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -1437,12 +1444,14 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{
@@ -1793,6 +1802,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 copy: z.ZodOptional<z.ZodString>;
                 newMessages: z.ZodOptional<z.ZodString>;
                 reconnect: z.ZodOptional<z.ZodString>;
+                newConversation: z.ZodOptional<z.ZodString>;
                 retry: z.ZodOptional<z.ZodString>;
                 unavailable: z.ZodOptional<z.ZodString>;
                 sessionExpired: z.ZodOptional<z.ZodString>;
@@ -1887,12 +1897,14 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 ltr: "ltr";
                 rtl: "rtl";
             }>>;
-            model: z.ZodObject<{
+            model: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"openai-compatible">;
                 baseUrl: z.ZodString;
                 model: z.ZodString;
                 apiKey: z.ZodString;
-            }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"noodle-managed">;
+            }, z.core.$strict>]>;
             allowedOrigins: z.ZodArray<z.ZodString>;
             surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 mode: z.ZodEnum<{

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -310,6 +310,7 @@ const assistantUiSchema = z
         copy: z.string().trim().min(1).max(80).optional(),
         newMessages: z.string().trim().min(1).max(80).optional(),
         reconnect: z.string().trim().min(1).max(80).optional(),
+        newConversation: z.string().trim().min(1).max(80).optional(),
         retry: z.string().trim().min(1).max(80).optional(),
         unavailable: z.string().trim().min(1).max(240).optional(),
         sessionExpired: z.string().trim().min(1).max(240).optional(),
@@ -343,14 +344,17 @@ const MAX_SERVER_INSTRUCTIONS = 4000;
 const sessionClaimsSchema = z.record(z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/, 'claim keys are identifier-style'), z.object({ exposeToModel: z.boolean().optional() }).strict());
 const embeddedAssistantSchema = z
     .object({
-    model: z
-        .object({
-        kind: z.literal('openai-compatible'),
-        baseUrl: z.string().trim().min(1),
-        model: z.string().trim().min(1),
-        apiKey: z.string().regex(/^[A-Za-z0-9_]+$/),
-    })
-        .strict(),
+    model: z.union([
+        z
+            .object({
+            kind: z.literal('openai-compatible'),
+            baseUrl: z.string().trim().min(1),
+            model: z.string().trim().min(1),
+            apiKey: z.string().regex(/^[A-Za-z0-9_]+$/),
+        })
+            .strict(),
+        z.object({ kind: z.literal('noodle-managed') }).strict(),
+    ]),
     allowedOrigins: z.array(assistantOriginOrVariableSchema).min(1),
     // The front doors this assistant serves (ADR 0201, amended 2026-08-12). Absent means the pre-0201
     // authenticated shape, so released artifacts keep their meaning; `allowedOrigins` stays the union

package/node_modules/@noodle-borg/control-plane/dist/portable.d.ts

@@ -4,5 +4,7 @@ export { InMemoryControlPlaneStore } from './in-memory-control-plane-store.js';
 export { bindInMemoryOrganizationStore, type InMemoryOrganizationOperations, InMemoryOrganizationStore, } from './in-memory-organization-store.js';
 export { InMemoryMcpSubdomainClaimStore, McpSubdomainCooldownError, McpSubdomainIdempotencyConflictError, McpSubdomainOwnerRequiredError, type McpSubdomainRouteRef, McpSubdomainUnavailableError, mcpSubdomainEndpointOptions, type ResolvedMcpTenantRef, resolveMcpSubdomainTenant, } from './mcp-subdomain-claims.js';
 export { domainFromEmail, domainKey, memberKey, normalizeSignupAllowlistValue, personalOrgSlug, personalOrgSlugSuffix, signupKey, } from './organization-helpers.js';
+export { type RollbackControlPlane, type RollbackOperationDependencies, type RollbackOperationInput, type RollbackOperationResult, type RollbackRegistry, rollbackDeploymentOperation, } from './rollback-deployment.js';
+export type { RollbackResult } from './rollback-result.js';
 export { DOMAIN_PATTERN, isSystemOwnedOrgSlug, OPENAI_APPS_CHALLENGE_MAX_LENGTH, SLUG_PATTERN, validateDomain, validateMcpSubdomain, validateOpenAIAppsChallenge, validateOrgMembershipDomain, validateOrgRole, validateSignupAllowlistKind, validateSlug, validateUserOwnedOrgSlug, } from './validation.js';
 //# sourceMappingURL=portable.d.ts.map

package/node_modules/@noodle-borg/control-plane/dist/portable.js

@@ -3,5 +3,6 @@ export { InMemoryControlPlaneStore } from './in-memory-control-plane-store.js';
 export { bindInMemoryOrganizationStore, InMemoryOrganizationStore, } from './in-memory-organization-store.js';
 export { InMemoryMcpSubdomainClaimStore, McpSubdomainCooldownError, McpSubdomainIdempotencyConflictError, McpSubdomainOwnerRequiredError, McpSubdomainUnavailableError, mcpSubdomainEndpointOptions, resolveMcpSubdomainTenant, } from './mcp-subdomain-claims.js';
 export { domainFromEmail, domainKey, memberKey, normalizeSignupAllowlistValue, personalOrgSlug, personalOrgSlugSuffix, signupKey, } from './organization-helpers.js';
+export { rollbackDeploymentOperation, } from './rollback-deployment.js';
 export { DOMAIN_PATTERN, isSystemOwnedOrgSlug, OPENAI_APPS_CHALLENGE_MAX_LENGTH, SLUG_PATTERN, validateDomain, validateMcpSubdomain, validateOpenAIAppsChallenge, validateOrgMembershipDomain, validateOrgRole, validateSignupAllowlistKind, validateSlug, validateUserOwnedOrgSlug, } from './validation.js';
 //# sourceMappingURL=portable.js.map

package/node_modules/@noodle-borg/control-plane/dist/rollback-deployment.d.ts

@@ -0,0 +1,61 @@
+import { type AuditSink, type DeploymentOperationTarget, type EndpointUrlOptions } from '@noodle-borg/module';
+import type { RollbackResult } from './rollback-result.js';
+export interface RollbackRegistry {
+    getAppArchivedAt(org: string, app: string): Promise<string | undefined>;
+    rollback(target: DeploymentOperationTarget, deploymentId: string): Promise<RollbackResult>;
+}
+export interface RollbackControlPlane {
+    getOrgMember(input: {
+        readonly org: string;
+        readonly subject: string;
+    }): Promise<{
+        readonly role: string;
+    } | undefined>;
+}
+export interface RollbackOperationDependencies {
+    readonly registry: RollbackRegistry;
+    readonly controlPlane: RollbackControlPlane;
+    readonly audit: AuditSink;
+}
+export interface RollbackOperationInput {
+    readonly actor: {
+        readonly subject: string;
+        readonly email?: string;
+        readonly superAdmin: boolean;
+    };
+    readonly target: DeploymentOperationTarget;
+    readonly deploymentId: string;
+    readonly reason?: string;
+    readonly publicBaseUrl: string;
+    readonly endpointOptions?: EndpointUrlOptions;
+}
+export type RollbackOperationResult = {
+    readonly ok: true;
+    readonly view: {
+        readonly target: DeploymentOperationTarget;
+        readonly rollback: {
+            readonly deploymentId: string;
+            readonly serverVersion?: string;
+            readonly previousDeploymentId?: string;
+            readonly alreadyActive: boolean;
+            readonly endpointUrl: string;
+            readonly accessMode: string;
+            readonly ownerSubject?: string;
+            readonly previousAccessMode?: string;
+            readonly serverName: string;
+            readonly createdAt: string;
+        };
+    };
+} | {
+    readonly ok: false;
+    readonly status: 403 | 404 | 409 | 503;
+    readonly code: 'forbidden' | 'app_archived' | 'deployment_not_found' | 'deployment_incompatible' | 'deployment_locked' | 'production_app_limit_exceeded' | 'billing_enforcement_unavailable';
+    readonly message: string;
+};
+/**
+ * Activate a previous deployment through the service's canonical governance boundary.
+ * HTTP routes, agent tools, and MCP App widgets must all call this operation rather than
+ * duplicating owner checks, commercial admission, endpoint construction, or audit behavior.
+ */
+export declare function rollbackDeploymentOperation(dependencies: RollbackOperationDependencies, input: RollbackOperationInput): Promise<RollbackOperationResult>;
+//# sourceMappingURL=rollback-deployment.d.ts.map

package/node_modules/@noodle-borg/{service/dist/operations → control-plane/dist}/rollback-deployment.js

@@ -1,5 +1,4 @@
-import { DeploymentActivationError } from '@noodle-borg/module';
-import { tenantMcpUrl } from '../registry-helpers.js';
+import { DeploymentActivationError, tenantMcpUrl, } from '@noodle-borg/module';
 /**
  * Activate a previous deployment through the service's canonical governance boundary.
  * HTTP routes, agent tools, and MCP App widgets must all call this operation rather than
@@ -81,6 +80,7 @@ export async function rollbackDeploymentOperation(dependencies, input) {
                 : {}),
             alreadyActive: result.alreadyActive,
             accessMode: result.accessMode,
+            ...(result.ownerSubject !== undefined ? { ownerSubject: result.ownerSubject } : {}),
             ...(result.previousAccessMode !== undefined
                 ? { previousAccessMode: result.previousAccessMode }
                 : {}),
@@ -101,6 +101,7 @@ export async function rollbackDeploymentOperation(dependencies, input) {
                 alreadyActive: result.alreadyActive,
                 endpointUrl,
                 accessMode: result.accessMode,
+                ...(result.ownerSubject !== undefined ? { ownerSubject: result.ownerSubject } : {}),
                 ...(result.previousAccessMode !== undefined
                     ? { previousAccessMode: result.previousAccessMode }
                     : {}),