@noodleseed/one 0.169.0 → 0.171.0

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export { authenticatedWebsite, embeddedAssistant, noodleManaged, openAICompatible, publicWebsite, } from './assistant.js';
+export { authenticatedWebsite, embeddedAssistant, noodleManaged, openAICompatible, publicMessaging, 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';
@@ -12,5 +12,6 @@ export { managedCollection, } from './managed-collection.js';
 export { noodlePlatform, noodlePlatformCatalog } from './platform.js';
 export { when, } from './recording.js';
 export { annotations, asset, isServerDefinition, prompt, resource, server, tool, widgetResult, } from './server.js';
+export { webExtract, } from './web-capabilities.js';
 export { z };
 //# sourceMappingURL=index.js.map

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 { algolia, annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, firecrawl, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedCollection, managedSecret, meilisearch, noodleManaged, noodlePlatform, openAICompatible, prompt, publicWebsite, resource, secret, server, site, tavily, tool, variable, when, z } from '@noodle-borg/authoring';\n");
+    writeFileSync(join(self, 'index.mjs'), "export { algolia, annotations, asset, authenticatedWebsite, bind, clientCredentials, connector, connection, customerAuth, customerEndpoint, embeddedAssistant, externalExchange, file, firecrawl, gmailConnector, googleWorkloadIdentity, handoffSession, knowledge, managedCollection, managedSecret, meilisearch, noodleManaged, noodlePlatform, openAICompatible, prompt, publicMessaging, publicWebsite, resource, secret, server, site, tavily, tool, variable, webExtract, 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 * from '@noodle-borg/authoring/react';\n");
 }

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

@@ -1,6 +1,7 @@
 import type { ConnectorRef } from './connectors.js';
 import type { AmbientContextOptions } from './context.js';
 import type { ResourceContext, ToolOptions } from './server.js';
+import type { WebExtractDeclaration } from './web-capabilities.js';
 export type SymbolicScope = Ref & Record<string, Ref>;
 export type ConnectorClient = Record<string, (args?: Readonly<Record<string, unknown>>) => SymbolicScope>;
 type RecordedStep = {
@@ -17,7 +18,7 @@ type RecordedStep = {
     readonly if?: string;
 };
 export declare function when<T>(condition: Cond, record: () => T): T;
-export declare function recordTool(fulfil: ToolOptions['fulfil'], connectors: Readonly<Record<string, ConnectorRef>>): Promise<{
+export declare function recordTool(fulfil: ToolOptions['fulfil'], connectors: Readonly<Record<string, ConnectorRef>>, capabilities?: readonly WebExtractDeclaration[]): Promise<{
     steps: RecordedStep[];
     output: Record<string, unknown>;
 }>;

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

@@ -17,7 +17,7 @@ export function when(condition, record) {
             activeRecording.pendingCondition = previous;
     }
 }
-export async function recordTool(fulfil, connectors) {
+export async function recordTool(fulfil, connectors, capabilities = []) {
     const ctx = newRecordingContext();
     activeRecording = ctx;
     try {
@@ -26,6 +26,7 @@ export async function recordTool(fulfil, connectors) {
             user: makeScope('user'),
             context: makeScope('context'),
             connectors: makeConnectors(connectors, ctx),
+            capabilities: makeCapabilities(capabilities, ctx),
             elicit: makeElicitor(ctx),
         });
         return { steps: ctx.steps, output: serializeMap(result) };
@@ -91,6 +92,33 @@ export async function recordAmbientContext(fulfil, connectors) {
 function newRecordingContext() {
     return { steps: [], counts: new Map(), stepIds: new Set() };
 }
+function makeCapabilities(declarations, ctx) {
+    const names = new Set(declarations.map((value) => value.name));
+    return new Proxy({}, {
+        get(_target, name) {
+            if (typeof name !== 'string')
+                return undefined;
+            if (!names.has(name))
+                throw new Error(`unknown capability "${name}"`);
+            return new Proxy({}, {
+                get(_client, method) {
+                    if (method !== 'extract')
+                        throw new Error(`unknown capability method "${String(method)}"`);
+                    return (request) => {
+                        const id = nextStepId(ctx, 'extract');
+                        ctx.steps.push({
+                            id,
+                            use: 'noodle_web.extract',
+                            args: serializeConnectorArgs({ name, request }),
+                            ...(ctx.pendingCondition ? { if: ctx.pendingCondition } : {}),
+                        });
+                        return makeScope(`steps.${id}`);
+                    };
+                },
+            });
+        },
+    });
+}
 function makeElicitor(ctx) {
     return ((options) => {
         if (!isValidName(options.id)) {

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

@@ -12,6 +12,7 @@ import { type JsonSchema } from './json-schema.js';
 import { type KnowledgeDeclaration } from './knowledge.js';
 import * as collections from './managed-collection.js';
 import { type ConnectorClient, type SymbolicScope } from './recording.js';
+import { type WebExtractDeclaration } from './web-capabilities.js';
 export type StateHandleKind = 'session' | 'draft' | 'selection' | 'search' | 'cart' | 'workflow';
 export type StateHandleScope = 'deployment' | 'caller';
 export interface StateHandleOptions {
@@ -53,6 +54,7 @@ export interface ServerOptions {
     readonly assistant?: EmbeddedAssistantConfig;
     /** Customer-owned knowledge components (ADR 0202): compile to generated `search_<name>` capabilities. */
     readonly knowledge?: readonly KnowledgeDeclaration[];
+    readonly capabilities?: readonly WebExtractDeclaration[];
     /** Typed managed records; operator-owned lifecycle and policy are bound outside reusable source. */
     readonly collections?: readonly collections.ManagedCollectionDeclaration[];
     readonly branding?: {
@@ -180,6 +182,7 @@ export interface ToolContext {
     readonly user: SymbolicScope;
     readonly context: SymbolicScope;
     readonly connectors: Record<string, ConnectorClient>;
+    readonly capabilities: Record<string, ConnectorClient>;
     /** Request one bounded, non-sensitive form input and continue with its symbolic response. */
     readonly elicit: (options: ElicitationOptions) => SymbolicScope;
 }

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

@@ -14,6 +14,7 @@ import { manifestKnowledge } from './knowledge.js';
 import * as collections from './managed-collection.js';
 import { manifestToolAnnotations } from './model-tool-visibility.js';
 import { recordFulfilment, recordTool, } from './recording.js';
+import { manifestWebCapability } from './web-capabilities.js';
 const WIDGET_RESULT_META_KEY = '__noodleResultMeta';
 export function server(name, options, definitions = []) {
     const { use = {}, provides = {} } = options;
@@ -127,7 +128,7 @@ class ServerBuilder {
             : await manifestContext(this.options.context, this.connectors);
         const tools = [];
         for (const tool of this.tools) {
-            const recorded = await recordTool(tool.options.fulfil, this.connectors);
+            const recorded = await recordTool(tool.options.fulfil, this.connectors, this.options.capabilities);
             const { discovery, requiredScopes, allowedRoles, ...authorization } = tool.options.authorization ?? {};
             tools.push({
                 name: tool.name,
@@ -209,6 +210,9 @@ class ServerBuilder {
                 ...(this.options.knowledge && this.options.knowledge.length > 0
                     ? { knowledge: this.options.knowledge.map(manifestKnowledge) }
                     : {}),
+                ...(this.options.capabilities?.length
+                    ? { capabilities: this.options.capabilities.map(manifestWebCapability) }
+                    : {}),
                 ...collections.manifestCollections(this.options.collections, this.connectors),
                 ...manifestVariables(this.options.variables),
                 ...(this.options.branding ? { branding: this.options.branding } : {}),

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

@@ -0,0 +1,17 @@
+import { type WebCapability, type WebPolicy } from '@noodle-borg/managed-capabilities';
+import type { NoodleManagedModel } from './assistant.js';
+import type { ToolAuthorizationOptions } from './server.js';
+export interface WebExtractOptions {
+    readonly title: string;
+    readonly description: string;
+    readonly provider: NoodleManagedModel;
+    readonly policy?: WebPolicy;
+    readonly authorization?: ToolAuthorizationOptions;
+}
+export type WebExtractDeclaration = WebCapability & {
+    readonly kind: 'web-extract';
+};
+/** Read explicit public pages through the platform's governed extraction capability. */
+export declare function webExtract(name: string, options: WebExtractOptions): WebExtractDeclaration;
+export declare function manifestWebCapability(value: WebExtractDeclaration): WebCapability;
+//# sourceMappingURL=web-capabilities.d.ts.map

package/node_modules/@noodle-borg/authoring/dist/web-capabilities.js

@@ -0,0 +1,15 @@
+import { webCapabilityBaseSchema, } from '@noodle-borg/managed-capabilities';
+/** Read explicit public pages through the platform's governed extraction capability. */
+export function webExtract(name, options) {
+    const { authorization, ...base } = options;
+    return {
+        kind: 'web-extract',
+        ...webCapabilityBaseSchema.parse({ name, class: 'web.extract.v1', ...base }),
+        ...(authorization === undefined ? {} : { authorization: structuredClone(authorization) }),
+    };
+}
+export function manifestWebCapability(value) {
+    const { kind: _kind, ...declaration } = value;
+    return structuredClone(declaration);
+}
+//# sourceMappingURL=web-capabilities.js.map

package/node_modules/@noodle-borg/authoring/package.json

@@ -30,6 +30,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.type-tests.json --noEmit"
   },
   "dependencies": {
+    "@noodle-borg/managed-capabilities": "0.0.0",
     "typescript": "^6.0.3",
     "@noodle-borg/compiler": "0.0.0",
     "@noodle-borg/connector-defs": "0.0.0",

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

@@ -10,6 +10,13 @@ export const CAPABILITY_NAMES = [
 ];
 /** Single public compatibility registry used by CLI output, docs, and release notes. */
 export const PRODUCT_FEATURES = [
+    {
+        id: 'bounded-public-page-extraction',
+        title: 'Bounded public-page extraction',
+        since: 'next',
+        description: 'Managed-only learning cohort: explicit public HTTPS pages through ordinary tools, with revisioned operator policy, shared budgets and evidence references. General search and BYO are not included.',
+        hosts: { claude: 'preview', chatgpt: 'preview', embedded: 'preview' },
+    },
     {
         id: 'mcp-core',
         title: 'MCP tools, resources, and prompts',

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

@@ -0,0 +1,121 @@
+const flag = (name, summary, type = 'string') => ({
+    name,
+    summary,
+    type,
+    ...(type === 'boolean' ? {} : { value: '<value>' }),
+    required: false,
+    repeatable: false,
+    sensitive: name === 'auth-token',
+    aliases: [],
+    conflictsWith: [],
+});
+const scope = [
+    flag('org', 'Organization.'),
+    flag('app', 'Application.'),
+    flag('env', 'Environment.'),
+    flag('service', 'Service URL.'),
+    flag('auth-token', 'Control-plane token.'),
+    flag('json', 'Machine-readable output.', 'boolean'),
+];
+const mutation = [flag('idempotency-key', 'Stable key for retrying this logical change.')];
+const revision = flag('expected-revision', 'Current revision from status; zero when creating.', 'number');
+const blockScope = flag('scope', 'local (default) or explicit provider block.');
+const participant = flag('participant-id', 'Protected participant identifier from events list.');
+const limits = [
+    'per-minute',
+    'per-hour',
+    'per-day',
+    'channel-per-day',
+    'new-participants-per-day',
+    'concurrent',
+    'pending-per-participant',
+    'pending',
+    'text-characters',
+    'daily-micro-usd',
+].map((name) => flag(name, `Lower the ${name} ceiling; zero disables this allowance.`, 'number'));
+const leaf = (name, summary, flags = []) => ({
+    name,
+    summary,
+    flags: [...scope, ...flags],
+    arguments: [],
+    jsonOutput: { mode: 'single' },
+});
+const group = (name, summary, subcommands) => ({ name, summary, subcommands, flags: [], arguments: [] });
+export const CHANNELS_COMMAND = {
+    name: 'channels',
+    section: 'operate',
+    summary: 'Connect and operate the same application on messaging channels.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        group('whatsapp', 'Configure the 360dialog channel, test readiness, and control public messaging.', [
+            leaf('status', 'Show configuration and current revision.'),
+            leaf('configure', 'Save a paused binding using managed secret references.', [
+                revision,
+                ...mutation,
+                flag('phone-number-id', '360dialog/Meta phone-number asset ID.'),
+                flag('api-key-secret', 'Managed secret name for the 360dialog key.'),
+                flag('webhook-secret', 'Independent managed callback secret name.'),
+                flag('capabilities', 'Comma-separated knowledge:name or tool:name selections.'),
+                flag('support-email', 'Contact shown when an answer cannot be completed.'),
+                ...limits,
+            ]),
+            leaf('doctor', 'Check deployment, storage, worker, model cost bound, and provider setup.', mutation),
+            leaf('enable', 'Enable after a successful current readiness check.', [
+                revision,
+                ...mutation,
+            ]),
+            leaf('pause', 'Stop new work and unsent replies.', [revision, ...mutation]),
+            leaf('disconnect', 'Fence this binding and retain governed receipts.', [
+                revision,
+                ...mutation,
+            ]),
+            group('webhook', 'Inspect or configure the owned provider callback.', [
+                leaf('inspect', 'Check URL and authentication without disclosing headers.'),
+                leaf('configure', 'Register the service-owned callback.', [revision, ...mutation]),
+            ]),
+            group('limits', 'Inspect or lower the approved limits.', [
+                leaf('get', 'Show limits.'),
+                leaf('set', 'Lower selected limits.', [revision, ...mutation, ...limits]),
+            ]),
+            leaf('usage', 'Show UTC-day settled and reserved inference spend.'),
+            group('blocks', 'Inspect local blocks.', [
+                leaf('list', 'List local and provider block evidence.', [
+                    flag('after', 'Cursor from the previous page.'),
+                ]),
+            ]),
+            leaf('block', 'Block locally; optionally request a provider block.', [
+                participant,
+                blockScope,
+                flag('phone-stdin', 'Read a phone number securely from standard input.', 'boolean'),
+                flag('until', 'Expiry as an ISO timestamp.'),
+                flag('indefinite', 'Explicitly retain this block until removed.', 'boolean'),
+                ...mutation,
+            ]),
+            leaf('unblock', 'Remove an explicitly selected block without resetting usage.', [
+                participant,
+                blockScope,
+                flag('phone-stdin', 'Supply the number if retained participant context has expired.', 'boolean'),
+                ...mutation,
+            ]),
+            group('cooldown', 'Inspect or clear an automatic cooldown.', [
+                leaf('inspect', 'Show a participant cooldown.', [participant]),
+                leaf('clear', 'Clear cooldown without resetting quotas.', [participant, ...mutation]),
+            ]),
+            group('events', 'Inspect content-free transport receipts.', [
+                leaf('list', 'List a page of events.', [
+                    flag('after', 'Cursor returned by the previous page.'),
+                ]),
+                leaf('inspect', 'Inspect one event.', [flag('event-id', 'Event identifier.')]),
+                leaf('reconcile', 'Read current receipt evidence without resending.', [
+                    flag('event-id', 'Event identifier.'),
+                    ...mutation,
+                ]),
+            ]),
+            group('conversation', 'Erase conversation content.', [
+                leaf('forget', 'Erase participant context and message content while preserving safeguards.', [participant, ...mutation]),
+            ]),
+        ]),
+    ],
+};
+//# sourceMappingURL=catalog-data-channels.js.map

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

@@ -67,6 +67,108 @@ const TENANT_TARGET_FLAGS = [
     JSON_FLAG,
 ];
 export const CATALOG_HOSTED_OBSERVABILITY = [
+    {
+        name: 'capabilities',
+        section: 'operate',
+        helpRank: 16,
+        summary: 'Inspect, configure and test bounded managed capabilities for an exact app/environment.',
+        arguments: [],
+        flags: [],
+        subcommands: [
+            {
+                ...SUBCOMMAND_FIELDS,
+                name: 'inspect',
+                summary: 'List capabilities or inspect one with effective policy.',
+                arguments: [
+                    {
+                        ...ARGUMENT_FIELDS,
+                        name: 'name',
+                        type: 'string',
+                        summary: 'Capability name.',
+                        required: false,
+                    },
+                ],
+                flags: TENANT_TARGET_FLAGS,
+                jsonOutput: { mode: 'single' },
+            },
+            {
+                ...SUBCOMMAND_FIELDS,
+                name: 'configure',
+                summary: 'Replace policy with a revision and retry-safe mutation ID.',
+                arguments: [
+                    {
+                        ...ARGUMENT_FIELDS,
+                        name: 'name',
+                        type: 'string',
+                        summary: 'Capability name.',
+                        required: true,
+                    },
+                ],
+                flags: [
+                    ...TENANT_TARGET_FLAGS,
+                    {
+                        ...FLAG_FIELDS,
+                        name: 'policy-file',
+                        type: 'string',
+                        value: '<path>',
+                        required: true,
+                        summary: 'Bounded JSON policy file.',
+                    },
+                    {
+                        ...FLAG_FIELDS,
+                        name: 'expected-revision',
+                        type: 'string',
+                        value: '<revision>',
+                        required: true,
+                        summary: 'Current policy revision; zero creates it.',
+                    },
+                    {
+                        ...FLAG_FIELDS,
+                        name: 'mutation-id',
+                        type: 'string',
+                        value: '<id>',
+                        required: true,
+                        summary: 'Stable ID reused for identical retries.',
+                    },
+                ],
+                jsonOutput: { mode: 'single' },
+            },
+            {
+                ...SUBCOMMAND_FIELDS,
+                name: 'test',
+                summary: 'Run a governed diagnostic without returning page bodies.',
+                arguments: [
+                    {
+                        ...ARGUMENT_FIELDS,
+                        name: 'name',
+                        type: 'string',
+                        summary: 'Capability name.',
+                        required: true,
+                    },
+                ],
+                flags: [
+                    ...TENANT_TARGET_FLAGS,
+                    {
+                        ...FLAG_FIELDS,
+                        name: 'request-file',
+                        type: 'string',
+                        value: '<path>',
+                        required: true,
+                        summary: 'JSON request containing explicit public URLs.',
+                    },
+                    {
+                        ...FLAG_FIELDS,
+                        name: 'mode',
+                        type: 'string',
+                        value: '<fixture|live>',
+                        required: true,
+                        summary: 'Fixture performs no website I/O; live fetches the specified pages.',
+                    },
+                ],
+                jsonOutput: { mode: 'single' },
+            },
+        ],
+    },
     {
         name: 'knowledge',
         section: 'operate',

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

@@ -4,6 +4,7 @@ export * from './catalog-data-auth-discovery.js';
 export * from './catalog-data-billing.js';
 export * from './catalog-data-bootstrap-authoring.js';
 export * from './catalog-data-bootstrap-pre-auth.js';
+export * from './catalog-data-channels.js';
 export * from './catalog-data-config.js';
 export * from './catalog-data-core.js';
 export * from './catalog-data-distributions.js';

package/node_modules/@noodle-borg/compiler/dist/artifact/assemble.js

@@ -40,6 +40,9 @@ export function assembleRuntimeArtifact({ manifest, options, runtimeBranding, ru
                 : {}),
             ...(manifest.server.auth !== undefined ? { auth: manifest.server.auth } : {}),
             ...(knowledge !== undefined && knowledge.length > 0 ? { knowledge } : {}),
+            ...(manifest.manifestVersion === '2' && manifest.server.capabilities?.length
+                ? { capabilities: manifest.server.capabilities }
+                : {}),
             ...(variables !== undefined && variables.length > 0 ? { variables } : {}),
             ...(managedCollections !== undefined && managedCollections.length > 0
                 ? { managedCollections }

package/node_modules/@noodle-borg/compiler/dist/artifact/config.js

@@ -20,7 +20,7 @@ function collectVariablesFromManagedOrigins(manifest, out) {
     const assistant = manifest.server.assistant;
     const values = [
         ...(assistant?.allowedOrigins ?? []),
-        ...(assistant?.surfaces?.flatMap((surface) => surface.origins) ?? []),
+        ...(assistant?.surfaces?.flatMap((surface) => surface.kind === 'messaging' ? [] : surface.origins) ?? []),
         ...(manifest.handoff?.allowedDomains ?? []),
     ];
     for (const value of values) {

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

@@ -1,5 +1,6 @@
 import type { CapabilityRequirementName } from '@noodle-borg/capabilities';
 import type { CompiledKnowledgeComponent } from '@noodle-borg/knowledge/portable';
+import type { WebCapability } from '@noodle-borg/managed-capabilities';
 import type { ArtifactVariableDeclaration } from '../business-variables.js';
 import type { CustomerEndpointPolicy } from '../customer-endpoint.js';
 import type { ManagedCollectionControls } from '../managed-collection-controls.js';
@@ -251,6 +252,7 @@ export interface ArtifactServer {
     readonly auth?: ArtifactAuth;
     /** Compiled knowledge components (ADR 0202, Core v2): descriptors + generated tool metadata, never bytes. */
     readonly knowledge?: readonly CompiledKnowledgeComponent[];
+    readonly capabilities?: readonly WebCapability[];
     /** Compiled managed-record schema intent; lifecycle and operator state remain outside artifacts. */
     readonly managedCollections?: readonly ArtifactManagedCollection[];
     /** Typed reusable managed-variable declarations, never live operator values. */

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

@@ -63,7 +63,8 @@
  * including independently validated credential bindings for sandboxed compute dependencies.
  */
 /** `0.21.0`: protected tools may opt into public descriptor discovery without execution permission. */
-export declare const ARTIFACT_SCHEMA_VERSION = "0.21.0";
+/** `0.22.0`: governed public-page extraction declarations and ordinary generated tools. */
+export declare const ARTIFACT_SCHEMA_VERSION = "0.22.0";
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
 //# sourceMappingURL=version.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/artifact/version.js

@@ -63,7 +63,8 @@
  * including independently validated credential bindings for sandboxed compute dependencies.
  */
 /** `0.21.0`: protected tools may opt into public descriptor discovery without execution permission. */
-export const ARTIFACT_SCHEMA_VERSION = '0.21.0';
+/** `0.22.0`: governed public-page extraction declarations and ordinary generated tools. */
+export const ARTIFACT_SCHEMA_VERSION = '0.22.0';
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export const MCP_APP_MIME_TYPE = 'text/html;profile=mcp-app';
 //# sourceMappingURL=version.js.map

package/node_modules/@noodle-borg/compiler/dist/compile.js

@@ -21,6 +21,7 @@ import { resolveSchemaUses } from './manifest/schema-refs.js';
 import { validateWebsiteProjection } from './manifest/website-projection.js';
 import { compileState } from './state-handles.js';
 import { suggestionFields } from './suggest.js';
+import { expandWebCapabilities } from './web-capabilities.js';
 import { openAiWidgetCsp, withAssetResourceDomain } from './widget-compile-helpers.js';
 import { resourceUiMeta, widgetHtml, widgetUri } from './widget-emit.js';
 import { widgetHtmlSizeErrors } from './widget-size-validation.js';
@@ -145,6 +146,7 @@ export function compileManifest(raw, options = {}) {
     // 2. Structural passes (catalog-independent): duplicate names, `$use` resolution, external refs,
     // fulfilment parsing. `$use` is resolved first so external-ref detection also scans bundled defs.
     const errors = widgetHtmlSizeErrors(manifest, runtimeBranding);
+    expandWebCapabilities(manifest, errors);
     const variables = compileVariableDeclarations(manifest.manifestVersion === '2' ? (manifest.server.variables ?? []) : [], manifest.tools.map((tool) => tool.name), errors);
     const managedCollections = compileManagedCollections(manifest.manifestVersion === '2' ? (manifest.server.collections ?? []) : [], manifest.tools.map((tool) => tool.name), errors, {
         ...(options.catalog === undefined ? {} : { catalog: options.catalog }),

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

@@ -1,7 +1,7 @@
 import type { AppPackageArtifactV1 } from '@noodle-borg/app-package';
 import type { RuntimeArtifact } from './artifact/types.js';
 import type { PackagedAsset } from './assets.js';
-export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
+export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'ambiguous_nested_connector_binding' | 'invalid_connector_call_graph' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_messaging_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
 export interface CompileError {
     readonly code: CompileErrorCode;
     /** Dotted path to the offending location (e.g. `tools.1.name`); empty string for the document root. */

package/node_modules/@noodle-borg/compiler/dist/fulfilment-emit.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { WEB_CATALOG_CONNECTOR, WEB_CONNECTOR_ID, WEB_CONNECTOR_VERSION, } from '@noodle-borg/managed-capabilities';
 import { computeSignatureHash } from './catalog/signature.js';
 import { resolveNestedOperations } from './nested-operations.js';
 import { docAnchorFor, suggestionFields } from './suggest.js';
@@ -38,7 +39,8 @@ function resolveOp(op, catalog, declared, usedAliases, errors, options, traversa
         operation: op.operation,
         resolved: false,
     };
-    if (!catalog)
+    const isWeb = declared[op.connectorAlias]?.id === WEB_CONNECTOR_ID;
+    if (!catalog && !isWeb)
         return unresolved;
     usedAliases.add(op.connectorAlias);
     const connectorRef = declared[op.connectorAlias];
@@ -52,7 +54,20 @@ function resolveOp(op, catalog, declared, usedAliases, errors, options, traversa
         });
         return unresolved;
     }
-    const connector = catalog.get(connectorRef.id, connectorRef.version);
+    const effectiveCatalog = {
+        get: (id, version) => id === WEB_CONNECTOR_ID && version === WEB_CONNECTOR_VERSION
+            ? WEB_CATALOG_CONNECTOR
+            : catalog?.get(id, version),
+    };
+    const connector = effectiveCatalog.get(connectorRef.id, connectorRef.version);
+    if (isWeb && (options.surface !== 'tool' || options.readOnly === true)) {
+        errors.push({
+            code: 'invalid_fulfilment',
+            path: `${op.path}.use`,
+            message: 'web extraction is available only in ordinary tools, never ambient context, resources or prompts',
+        });
+        return unresolved;
+    }
     if (!connector) {
         errors.push({
             code: 'connector_not_in_catalog',
@@ -96,7 +111,7 @@ function resolveOp(op, catalog, declared, usedAliases, errors, options, traversa
         connector,
         operation: op.operation,
         path: op.path,
-        catalog,
+        catalog: effectiveCatalog,
         declared,
         errors,
         ...(traversal === undefined ? {} : { traversal }),