@noodleseed/one 0.36.0 → 0.37.0

package/node_modules/@noodle-borg/protocol/dist/stateless.js.map

@@ -1 +1 @@
-{"version":3,"file":"stateless.js","sourceRoot":"","sources":["../src/stateless.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,oDAAoD,CAAC;AAEnG,OAAO,EAAE,cAAc,EAAoD,MAAM,iBAAiB,CAAC;AAEnG;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,MAAsB,EACtB,GAAoB,EACpB,GAAmB,EACnB,UAAmB,EACnB,UAAkC,EAAE;IAEpC,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,kGAAkG;IAClG,oGAAoG;IACpG,iCAAiC;IACjC,MAAM,SAAS,GAAG,IAAI,6BAA6B,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC;IAClF,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;QACnB,KAAK,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC,CAAC,CAAC;IACH,gGAAgG;IAChG,sGAAsG;IACtG,MAAM,MAAM,CAAC,OAAO,CAAC,SAAsB,CAAC,CAAC;IAC7C,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;AACtD,CAAC"}
+{"version":3,"file":"stateless.js","sourceRoot":"","sources":["../src/stateless.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAE,MAAM,oDAAoD,CAAC;AAEnG,OAAO,EAAE,cAAc,EAAoD,MAAM,iBAAiB,CAAC;AAEnG;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,MAAsB,EACtB,GAAoB,EACpB,GAAmB,EACnB,UAAmB,EACnB,UAAkC,EAAE;IAEpC,mGAAmG;IACnG,oGAAoG;IACpG,sGAAsG;IACtG,qGAAqG;IACrG,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,EAAE;QACpC,GAAG,OAAO;QACV,wBAAwB,EAAE,aAAa;KACxC,CAAC,CAAC;IACH,kGAAkG;IAClG,oGAAoG;IACpG,iCAAiC;IACjC,MAAM,SAAS,GAAG,IAAI,6BAA6B,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC;IAClF,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;QACnB,KAAK,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC,CAAC,CAAC;IACH,gGAAgG;IAChG,sGAAsG;IACtG,MAAM,MAAM,CAAC,OAAO,CAAC,SAAsB,CAAC,CAAC;IAC7C,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;AACtD,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/tool-interaction.d.ts

@@ -0,0 +1,29 @@
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { type RuntimeArtifact } from '@noodle-borg/compiler';
+import { type ExecuteDeps, type ExecutionError } from '@noodle-borg/runtime';
+type ArtifactTool = RuntimeArtifact['tools'][number];
+export type McpToolInteractionOutcome = {
+    readonly status: 'completed';
+    readonly output: unknown;
+} | {
+    readonly status: 'failed';
+    readonly error: ExecutionError;
+} | {
+    readonly status: 'stopped';
+    readonly action: 'decline' | 'cancel';
+    readonly source: 'input' | 'confirmation';
+};
+export interface McpToolInteractionInput {
+    readonly server: Server;
+    readonly artifact: RuntimeArtifact;
+    readonly tool: ArtifactTool | undefined;
+    readonly toolName: string;
+    readonly toolArguments: unknown;
+    readonly deps: ExecuteDeps;
+    readonly formElicitationTransport?: 'bidirectional' | 'unavailable';
+    readonly onProtocolError: (errorKind: 'elicitation_unavailable' | 'invalid_confirmation_flow') => void;
+}
+/** Execute one MCP tool through only standard negotiated form interactions. */
+export declare function runMcpToolInteraction({ server, artifact, tool, toolName, toolArguments, deps, formElicitationTransport, onProtocolError, }: McpToolInteractionInput): Promise<McpToolInteractionOutcome>;
+export {};
+//# sourceMappingURL=tool-interaction.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/tool-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-interaction.d.ts","sourceRoot":"","sources":["../src/tool-interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAOxE,OAAO,EAAE,KAAK,eAAe,EAA4B,MAAM,uBAAuB,CAAC;AACvF,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,cAAc,EAOpB,MAAM,sBAAsB,CAAC;AAM9B,KAAK,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,MAAM,MAAM,yBAAyB,GACjC;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAAC;CAC3C,CAAC;AAEN,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,wBAAwB,CAAC,EAAE,eAAe,GAAG,aAAa,CAAC;IACpE,QAAQ,CAAC,eAAe,EAAE,CACxB,SAAS,EAAE,yBAAyB,GAAG,2BAA2B,KAC/D,IAAI,CAAC;CACX;AAED,+EAA+E;AAC/E,wBAAsB,qBAAqB,CAAC,EAC1C,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,IAAI,EACJ,wBAAwB,EACxB,eAAe,GAChB,EAAE,uBAAuB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CA2E9D"}

package/node_modules/@noodle-borg/protocol/dist/tool-interaction.js

@@ -0,0 +1,74 @@
+import { ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { requiresToolConfirmation } from '@noodle-borg/compiler';
+import { executePreparedTool, executeToolInteractive, isInputRequired, prepareToolForConfirmation, resumeTool, resumeToolPreparation, } from '@noodle-borg/runtime';
+import { confirmationElicitationRequest, isAffirmativeConfirmation, } from './confirmation-elicitation.js';
+/** Execute one MCP tool through only standard negotiated form interactions. */
+export async function runMcpToolInteraction({ server, artifact, tool, toolName, toolArguments, deps, formElicitationTransport, onProtocolError, }) {
+    const confirmationRequired = tool !== undefined && requiresToolConfirmation(tool.annotations);
+    if ((confirmationRequired || toolRequiresFormElicitation(tool)) &&
+        !supportsFormElicitation(server, formElicitationTransport)) {
+        onProtocolError('elicitation_unavailable');
+        throw new McpError(ErrorCode.InternalError, 'this client and transport cannot complete the required user interaction');
+    }
+    if (confirmationRequired && tool !== undefined) {
+        let preparation = await prepareToolForConfirmation(artifact, toolName, toolArguments, deps);
+        while (preparation.status === 'input_required') {
+            const response = await requestFormElicitation(server, {
+                mode: 'form',
+                message: preparation.request.message,
+                requestedSchema: preparation.request
+                    .requestedSchema,
+            }, () => onProtocolError('elicitation_unavailable'));
+            preparation = await resumeToolPreparation(artifact, preparation.continuation, response, deps);
+        }
+        if (preparation.status === 'stopped') {
+            return { ...preparation, source: 'input' };
+        }
+        if (preparation.status === 'failed')
+            return preparation;
+        const confirmation = confirmationElicitationRequest(tool, preparation.review);
+        if (!confirmation.ok) {
+            throw new McpError(ErrorCode.InternalError, 'the prepared action cannot be shown completely and was not executed');
+        }
+        const response = await requestFormElicitation(server, confirmation.request, () => onProtocolError('elicitation_unavailable'));
+        if (response.action !== 'accept') {
+            return { status: 'stopped', action: response.action, source: 'confirmation' };
+        }
+        if (!isAffirmativeConfirmation(response)) {
+            return { status: 'stopped', action: 'decline', source: 'confirmation' };
+        }
+        const result = await executePreparedTool(artifact, preparation.continuation, deps);
+        if (result.status === 'input_required') {
+            onProtocolError('invalid_confirmation_flow');
+            throw new McpError(ErrorCode.InternalError, 'the prepared action reached an unexpected input boundary');
+        }
+        return result.status === 'stopped' ? { ...result, source: 'input' } : result;
+    }
+    let result = await executeToolInteractive(artifact, toolName, toolArguments, deps);
+    while (isInputRequired(result)) {
+        const response = await requestFormElicitation(server, {
+            mode: 'form',
+            message: result.request.message,
+            requestedSchema: result.request
+                .requestedSchema,
+        }, () => onProtocolError('elicitation_unavailable'));
+        result = await resumeTool(artifact, result.continuation, response, deps);
+    }
+    return result.status === 'stopped' ? { ...result, source: 'input' } : result;
+}
+function toolRequiresFormElicitation(tool) {
+    return (tool?.fulfilment.kind === 'flow' && tool.fulfilment.steps.some((step) => step.kind === 'elicit'));
+}
+function supportsFormElicitation(server, transport) {
+    return (transport !== 'unavailable' && server.getClientCapabilities()?.elicitation?.form !== undefined);
+}
+async function requestFormElicitation(server, params, onUnavailable) {
+    try {
+        return await server.elicitInput(params);
+    }
+    catch {
+        onUnavailable();
+        throw new McpError(ErrorCode.InternalError, 'this client cannot complete the required user interaction');
+    }
+}
+//# sourceMappingURL=tool-interaction.js.map

package/node_modules/@noodle-borg/protocol/dist/tool-interaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-interaction.js","sourceRoot":"","sources":["../src/tool-interaction.ts"],"names":[],"mappings":"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"}

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/widget/bootstrap.ts"],"names":[],"mappings":"AAMA,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,EAAE,MAkxBrC,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/widget/bootstrap.ts"],"names":[],"mappings":"AAOA,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,EAAE,MAsxBrC,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.js

@@ -1,6 +1,7 @@
 import { WIDGET_FLOW_SOURCE } from './flow-bootstrap.js';
 import { WIDGET_FORMAT_SOURCE } from './format-bootstrap.js';
 import { WIDGET_HANDOFF_SOURCE } from './handoff-bootstrap.js';
+import { WIDGET_MODEL_CONTEXT_SOURCE } from './model-context-bootstrap.js';
 import { OPENAI_WIDGET_BRIDGE_SOURCE } from './openai-bridge.js';
 import { WIDGET_REACT_BRIDGE_SOURCE } from './react-bridge-bootstrap.js';
 /** Widget runtime bootstrap, eval-tested in widget-runtime.test.ts. */
@@ -18,7 +19,7 @@ ${OPENAI_WIDGET_BRIDGE_SOURCE}
   } else {
     return;
   }
-
+${WIDGET_MODEL_CONTEXT_SOURCE}  guardModelContextUpdates(app);
 ${WIDGET_REACT_BRIDGE_SOURCE}
   const get = (o, p) => String(p).split('.').reduce((x, k) => (x == null ? undefined : x[k]), o);
 
@@ -378,10 +379,14 @@ ${WIDGET_FORMAT_SOURCE}
   function persistWidgetState() {
     try {
       if (typeof app.setWidgetState !== 'function') return;
+      const saved = readWidgetState();
+      const modelContent = saved && Object.prototype.hasOwnProperty.call(saved, 'modelContent')
+        ? saved.modelContent
+        : null;
       const viewParams = nonEmptyViewParams(globalThis.__noodleViewParams || {});
       const overlayStack = globalThis.__noodleOverlayStack || [];
       app.setWidgetState({
-        modelContent: null,
+        modelContent,
         privateContent: {
           activeView: globalThis.__noodleActiveView || null,
           state: stateData(),
@@ -779,9 +784,9 @@ ${WIDGET_HANDOFF_SOURCE}
   // Register handlers BEFORE connect() so no one-shot host notification is missed.
   app.ontoolresult = (p) => bind(fromResult(p));
   app.ontoolinput = (p) => bindInput(p && p.arguments);
-  app.ontoolcancelled = () => clearBusy();
+  app.ontoolcancelled = () => { clearBusy(); notifyReact('noodle:toolcancelled'); };
   app.onhostcontextchanged = (p) => { theme(p); applyCapabilities(); };
-  app.onteardown = () => { try { clearBusy(); } catch (e) {} return {}; };
+  app.onteardown = () => { try { clearBusy(); notifyReact('noodle:teardown'); } catch (e) {} return {}; };
   installReactBridge();
   wireActions();
   restoreWidgetState();

package/node_modules/@noodle-borg/protocol/dist/widget/bootstrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/widget/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAEzE,uEAAuE;AACvE,MAAM,CAAC,MAAM,uBAAuB,GAAW;;EAE7C,2BAA2B;;;;;;;;;;;;;EAa3B,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJ1B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2OpB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHlB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgRtB,CAAC"}
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/widget/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAEzE,uEAAuE;AACvE,MAAM,CAAC,MAAM,uBAAuB,GAAW;;EAE7C,2BAA2B;;;;;;;;;;;;EAY3B,2BAA2B;EAC3B,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJ1B,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+OpB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHlB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgRtB,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/model-context-bootstrap.d.ts

@@ -0,0 +1,3 @@
+/** Shared runtime guard for every widget-to-host model-context path, including raw HTML actions. */
+export declare const WIDGET_MODEL_CONTEXT_SOURCE = "\n  const MAX_MODEL_CONTEXT_BYTES = 16 * 1024;\n  const MAX_MODEL_CONTEXT_DEPTH = 8;\n  const MAX_MODEL_CONTEXT_ENTRIES = 128;\n  const MODEL_CONTEXT_SENSITIVE_KEY = /(?:secret|token|api[-_]?key|password|credential|authorization|cookie)/i;\n  const MODEL_CONTEXT_CREDENTIAL_TEXT = /(?:-----BEGIN [A-Z ]*PRIVATE KEY-----|\\bsk-[A-Za-z0-9_-]{20,}\\b|\\b(?:bearer|basic)\\s+[A-Za-z0-9._~+/=-]{20,}\\b|\\b[A-Za-z0-9_-]{16,}\\.[A-Za-z0-9_-]{16,}\\.[A-Za-z0-9_-]{16,}\\b)/i;\n  function hasModelContextToJSON(value) {\n    let current = value;\n    const visited = new Set();\n    while (current !== null && !visited.has(current)) {\n      visited.add(current);\n      if (Object.getOwnPropertyDescriptor(current, 'toJSON') !== undefined) return true;\n      current = Object.getPrototypeOf(current);\n    }\n    return false;\n  }\n  function copyModelContextValue(value, path, depth, ancestors) {\n    if (depth > MAX_MODEL_CONTEXT_DEPTH) throw new Error('Model context exceeds the maximum nesting depth at ' + path);\n    if (typeof value === 'string') {\n      if (MODEL_CONTEXT_CREDENTIAL_TEXT.test(value)) throw new Error('Model context contains credential-shaped text at ' + path);\n      return value;\n    }\n    if (value === null || typeof value === 'boolean' ||\n        (typeof value === 'number' && Number.isFinite(value))) return value;\n    if (!value || typeof value !== 'object') throw new Error('Model context contains a non-JSON value at ' + path);\n    if (hasModelContextToJSON(value)) throw new Error('Model context must not define or inherit toJSON at ' + path);\n    const prototype = Object.getPrototypeOf(value);\n    if (Array.isArray(value)) {\n      if (prototype !== Array.prototype) throw new Error('Model context arrays must use the standard JSON prototype at ' + path);\n    } else if (prototype !== Object.prototype && prototype !== null) {\n      throw new Error('Model context objects must be plain records at ' + path);\n    }\n    if (ancestors.has(value)) throw new Error('Model context contains a cycle at ' + path);\n\n    if (Array.isArray(value)) {\n      if (value.length > MAX_MODEL_CONTEXT_ENTRIES) throw new Error('Model context has more than 128 entries at ' + path);\n      const copy = [];\n      ancestors.add(value);\n      for (let index = 0; index < value.length; index += 1) {\n        const entry = Object.prototype.hasOwnProperty.call(value, index) ? value[index] : null;\n        copy.push(copyModelContextValue(entry, path + '.' + index, depth + 1, ancestors));\n      }\n      ancestors.delete(value);\n      return copy;\n    }\n\n    const entries = Object.entries(value);\n    if (entries.length > MAX_MODEL_CONTEXT_ENTRIES) throw new Error('Model context has more than 128 entries at ' + path);\n    const copy = Object.create(null);\n    ancestors.add(value);\n    for (const [key, entry] of entries) {\n      if (MODEL_CONTEXT_SENSITIVE_KEY.test(key)) {\n        throw new Error('Model context contains sensitive key ' + path + '.' + key);\n      }\n      copy[key] = copyModelContextValue(entry, path + '.' + key, depth + 1, ancestors);\n    }\n    ancestors.delete(value);\n    return copy;\n  }\n  function copyModelContextUpdate(update) {\n    const copy = copyModelContextValue(update, '$', 0, new Set());\n    if (!copy || typeof copy !== 'object' || Array.isArray(copy)) {\n      throw new Error('Model context must be a JSON object');\n    }\n    const encoded = JSON.stringify(copy);\n    if (new TextEncoder().encode(encoded).byteLength > MAX_MODEL_CONTEXT_BYTES) {\n      throw new Error('Model context must not exceed 16 KiB');\n    }\n    return copy;\n  }\n  function guardModelContextUpdates(target) {\n    if (!target || typeof target.updateModelContext !== 'function') return;\n    const publish = target.updateModelContext.bind(target);\n    target.updateModelContext = (update) => {\n      return publish(copyModelContextUpdate(update));\n    };\n  }\n";
+//# sourceMappingURL=model-context-bootstrap.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/widget/model-context-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-context-bootstrap.d.ts","sourceRoot":"","sources":["../../src/widget/model-context-bootstrap.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,eAAO,MAAM,2BAA2B,i2HA6EvC,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/model-context-bootstrap.js

@@ -0,0 +1,80 @@
+/** Shared runtime guard for every widget-to-host model-context path, including raw HTML actions. */
+export const WIDGET_MODEL_CONTEXT_SOURCE = `
+  const MAX_MODEL_CONTEXT_BYTES = 16 * 1024;
+  const MAX_MODEL_CONTEXT_DEPTH = 8;
+  const MAX_MODEL_CONTEXT_ENTRIES = 128;
+  const MODEL_CONTEXT_SENSITIVE_KEY = /(?:secret|token|api[-_]?key|password|credential|authorization|cookie)/i;
+  const MODEL_CONTEXT_CREDENTIAL_TEXT = /(?:-----BEGIN [A-Z ]*PRIVATE KEY-----|\\bsk-[A-Za-z0-9_-]{20,}\\b|\\b(?:bearer|basic)\\s+[A-Za-z0-9._~+/=-]{20,}\\b|\\b[A-Za-z0-9_-]{16,}\\.[A-Za-z0-9_-]{16,}\\.[A-Za-z0-9_-]{16,}\\b)/i;
+  function hasModelContextToJSON(value) {
+    let current = value;
+    const visited = new Set();
+    while (current !== null && !visited.has(current)) {
+      visited.add(current);
+      if (Object.getOwnPropertyDescriptor(current, 'toJSON') !== undefined) return true;
+      current = Object.getPrototypeOf(current);
+    }
+    return false;
+  }
+  function copyModelContextValue(value, path, depth, ancestors) {
+    if (depth > MAX_MODEL_CONTEXT_DEPTH) throw new Error('Model context exceeds the maximum nesting depth at ' + path);
+    if (typeof value === 'string') {
+      if (MODEL_CONTEXT_CREDENTIAL_TEXT.test(value)) throw new Error('Model context contains credential-shaped text at ' + path);
+      return value;
+    }
+    if (value === null || typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value))) return value;
+    if (!value || typeof value !== 'object') throw new Error('Model context contains a non-JSON value at ' + path);
+    if (hasModelContextToJSON(value)) throw new Error('Model context must not define or inherit toJSON at ' + path);
+    const prototype = Object.getPrototypeOf(value);
+    if (Array.isArray(value)) {
+      if (prototype !== Array.prototype) throw new Error('Model context arrays must use the standard JSON prototype at ' + path);
+    } else if (prototype !== Object.prototype && prototype !== null) {
+      throw new Error('Model context objects must be plain records at ' + path);
+    }
+    if (ancestors.has(value)) throw new Error('Model context contains a cycle at ' + path);
+
+    if (Array.isArray(value)) {
+      if (value.length > MAX_MODEL_CONTEXT_ENTRIES) throw new Error('Model context has more than 128 entries at ' + path);
+      const copy = [];
+      ancestors.add(value);
+      for (let index = 0; index < value.length; index += 1) {
+        const entry = Object.prototype.hasOwnProperty.call(value, index) ? value[index] : null;
+        copy.push(copyModelContextValue(entry, path + '.' + index, depth + 1, ancestors));
+      }
+      ancestors.delete(value);
+      return copy;
+    }
+
+    const entries = Object.entries(value);
+    if (entries.length > MAX_MODEL_CONTEXT_ENTRIES) throw new Error('Model context has more than 128 entries at ' + path);
+    const copy = Object.create(null);
+    ancestors.add(value);
+    for (const [key, entry] of entries) {
+      if (MODEL_CONTEXT_SENSITIVE_KEY.test(key)) {
+        throw new Error('Model context contains sensitive key ' + path + '.' + key);
+      }
+      copy[key] = copyModelContextValue(entry, path + '.' + key, depth + 1, ancestors);
+    }
+    ancestors.delete(value);
+    return copy;
+  }
+  function copyModelContextUpdate(update) {
+    const copy = copyModelContextValue(update, '$', 0, new Set());
+    if (!copy || typeof copy !== 'object' || Array.isArray(copy)) {
+      throw new Error('Model context must be a JSON object');
+    }
+    const encoded = JSON.stringify(copy);
+    if (new TextEncoder().encode(encoded).byteLength > MAX_MODEL_CONTEXT_BYTES) {
+      throw new Error('Model context must not exceed 16 KiB');
+    }
+    return copy;
+  }
+  function guardModelContextUpdates(target) {
+    if (!target || typeof target.updateModelContext !== 'function') return;
+    const publish = target.updateModelContext.bind(target);
+    target.updateModelContext = (update) => {
+      return publish(copyModelContextUpdate(update));
+    };
+  }
+`;
+//# sourceMappingURL=model-context-bootstrap.js.map

package/node_modules/@noodle-borg/protocol/dist/widget/model-context-bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-context-bootstrap.js","sourceRoot":"","sources":["../../src/widget/model-context-bootstrap.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6E1C,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/openai-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai-bridge.d.ts","sourceRoot":"","sources":["../../src/widget/openai-bridge.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,EAAE,MAsEzC,CAAC"}
+{"version":3,"file":"openai-bridge.d.ts","sourceRoot":"","sources":["../../src/widget/openai-bridge.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,EAAE,MAkFzC,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/openai-bridge.js

@@ -2,6 +2,10 @@
 export const OPENAI_WIDGET_BRIDGE_SOURCE = `
   function makeOpenAiApp(o) {
     const msgText = (m) => (m && m.content && m.content[0] && m.content[0].text) || '';
+    let latestModelContent = o.widgetState && typeof o.widgetState === 'object' &&
+      Object.prototype.hasOwnProperty.call(o.widgetState, 'modelContent')
+      ? o.widgetState.modelContent
+      : null;
     const widgetPrivateContent = () => {
       const s = o.widgetState;
       return s && typeof s === 'object' && s.privateContent && typeof s.privateContent === 'object'
@@ -24,14 +28,22 @@ export const OPENAI_WIDGET_BRIDGE_SOURCE = `
       openLink: (p) => (typeof o.openExternal === 'function' ? o.openExternal({ href: p && p.url }) : undefined),
       requestDisplayMode: (p) =>
         typeof o.requestDisplayMode === 'function' ? o.requestDisplayMode({ mode: p && p.mode }) : undefined,
-      getWidgetState: () => o.widgetState,
-      setWidgetState: (p) =>
-        typeof o.setWidgetState === 'function' ? o.setWidgetState(p) : undefined,
+      getWidgetState: () => {
+        const current = o.widgetState && typeof o.widgetState === 'object' ? o.widgetState : {};
+        return { ...current, modelContent: latestModelContent };
+      },
+      setWidgetState: (p) => {
+        if (p && typeof p === 'object' && Object.prototype.hasOwnProperty.call(p, 'modelContent')) {
+          latestModelContent = p.modelContent;
+        }
+        return typeof o.setWidgetState === 'function' ? o.setWidgetState(p) : undefined;
+      },
       updateModelContext: (p) => {
+        latestModelContent = modelContent(p);
         if (typeof o.updateModelContext === 'function') return o.updateModelContext(p);
         if (typeof o.setWidgetState !== 'function') return undefined;
         return o.setWidgetState({
-          modelContent: modelContent(p),
+          modelContent: latestModelContent,
           privateContent: widgetPrivateContent(),
           imageIds: o.widgetState && Array.isArray(o.widgetState.imageIds) ? o.widgetState.imageIds : [],
         });

package/node_modules/@noodle-borg/protocol/dist/widget/openai-bridge.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai-bridge.js","sourceRoot":"","sources":["../../src/widget/openai-bridge.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,CAAC,MAAM,2BAA2B,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsElD,CAAC"}
+{"version":3,"file":"openai-bridge.js","sourceRoot":"","sources":["../../src/widget/openai-bridge.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,CAAC,MAAM,2BAA2B,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFlD,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/react-bridge-bootstrap.d.ts

@@ -1,3 +1,3 @@
 /** React helper bridge source injected into the shared widget bootstrap. */
-export declare const WIDGET_REACT_BRIDGE_SOURCE = "\n  function notifyReact(eventName) {\n    globalThis.__noodleReactVersion = (globalThis.__noodleReactVersion || 0) + 1;\n    try { globalThis.dispatchEvent(new CustomEvent(eventName)); } catch (e) {}\n  }\n  function installReactBridge() {\n    globalThis.__noodleReactBridge = {\n      getToolResult: () => ({ structuredContent: globalThis.__noodleData || {} }),\n      getViewState: () => stateData(),\n      setWidgetState: (patch) => setState(patch || {}),\n      getLayout: () => {\n        const context = (app.getHostContext && app.getHostContext()) || globalThis.__noodleLayout || {};\n        const capabilities = (app.getHostCapabilities && app.getHostCapabilities()) || {};\n        const hostInfo = (app.getHostVersion && app.getHostVersion()) || {};\n        const modes = Array.isArray(context.availableDisplayModes)\n          ? context.availableDisplayModes.filter((mode) => mode === 'inline' || mode === 'fullscreen' || mode === 'pip')\n          : [];\n        return {\n          theme: context.theme === 'dark' ? 'dark' : 'light',\n          displayMode: context.displayMode === 'fullscreen' || context.displayMode === 'pip'\n            ? context.displayMode\n            : 'inline',\n          ...(modes.length ? { availableDisplayModes: modes } : {}),\n          ...(context.containerDimensions ? { containerDimensions: { ...context.containerDimensions } } : {}),\n          ...(context.locale ? { locale: context.locale } : {}),\n          ...(context.timeZone ? { timeZone: context.timeZone } : {}),\n          ...(hostInfo.name ? { host: String(hostInfo.name) } : {}),\n          ...(context.platform ? { platform: context.platform } : {}),\n          ...(context.deviceCapabilities ? { deviceCapabilities: { ...context.deviceCapabilities } } : {}),\n          ...(context.safeAreaInsets ? { safeAreaInsets: { ...context.safeAreaInsets } } : {}),\n          supports: {\n            fullscreen: modes.includes('fullscreen'),\n            pip: modes.includes('pip'),\n            openExternal: Boolean(capabilities.openLinks || capabilities.openLink),\n            followUpMessage: Boolean(capabilities.message),\n          },\n        };\n      },\n      getBranding: () => globalThis.__noodleBranding || {},\n      callServerTool: (request) => app.callServerTool({\n        name: request && request.name,\n        arguments: request ? request.arguments : undefined,\n      }),\n      openExternal: (url) => app.openLink({ url: String(url || '') }),\n      sendFollowUpMessage: (message) => app.sendMessage({\n        role: 'user',\n        content: [{ type: 'text', text: String((message && message.prompt) || '') }],\n      }),\n      requestDisplayMode: (mode) => app.requestDisplayMode({ mode }),\n    };\n    notifyReact('noodle:bridge');\n  }\n";
+export declare const WIDGET_REACT_BRIDGE_SOURCE = "\n  function notifyReact(eventName) {\n    globalThis.__noodleReactVersion = (globalThis.__noodleReactVersion || 0) + 1;\n    try { globalThis.dispatchEvent(new CustomEvent(eventName)); } catch (e) {}\n  }\n  function installReactBridge() {\n    globalThis.__noodleReactBridge = {\n      getToolResult: () => ({ structuredContent: globalThis.__noodleData || {} }),\n      getViewState: () => stateData(),\n      setWidgetState: (patch) => setState(patch || {}),\n      getLayout: () => {\n        const context = (app.getHostContext && app.getHostContext()) || globalThis.__noodleLayout || {};\n        const capabilities = (app.getHostCapabilities && app.getHostCapabilities()) || {};\n        const hostInfo = (app.getHostVersion && app.getHostVersion()) || {};\n        const modes = Array.isArray(context.availableDisplayModes)\n          ? context.availableDisplayModes.filter((mode) => mode === 'inline' || mode === 'fullscreen' || mode === 'pip')\n          : [];\n        return {\n          theme: context.theme === 'dark' ? 'dark' : 'light',\n          displayMode: context.displayMode === 'fullscreen' || context.displayMode === 'pip'\n            ? context.displayMode\n            : 'inline',\n          ...(modes.length ? { availableDisplayModes: modes } : {}),\n          ...(context.containerDimensions ? { containerDimensions: { ...context.containerDimensions } } : {}),\n          ...(context.locale ? { locale: context.locale } : {}),\n          ...(context.timeZone ? { timeZone: context.timeZone } : {}),\n          ...(hostInfo.name ? { host: String(hostInfo.name) } : {}),\n          ...(context.platform ? { platform: context.platform } : {}),\n          ...(context.deviceCapabilities ? { deviceCapabilities: { ...context.deviceCapabilities } } : {}),\n          ...(context.safeAreaInsets ? { safeAreaInsets: { ...context.safeAreaInsets } } : {}),\n          supports: {\n            fullscreen: modes.includes('fullscreen'),\n            pip: modes.includes('pip'),\n            openExternal: Boolean(capabilities.openLinks || capabilities.openLink),\n            followUpMessage: Boolean(capabilities.message),\n            modelContext: Boolean(capabilities.updateModelContext || capabilities.modelContext),\n          },\n        };\n      },\n      getBranding: () => globalThis.__noodleBranding || {},\n      callServerTool: (request) => app.callServerTool({\n        name: request && request.name,\n        arguments: request ? request.arguments : undefined,\n      }),\n      openExternal: (url) => app.openLink({ url: String(url || '') }),\n      sendFollowUpMessage: (message) => app.sendMessage({\n        role: 'user',\n        content: [{ type: 'text', text: String((message && message.prompt) || '') }],\n      }),\n      updateModelContext: (update) => app.updateModelContext(update || {}),\n      requestDisplayMode: (mode) => app.requestDisplayMode({ mode }),\n    };\n    notifyReact('noodle:bridge');\n  }\n";
 //# sourceMappingURL=react-bridge-bootstrap.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/widget/react-bridge-bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react-bridge-bootstrap.d.ts","sourceRoot":"","sources":["../../src/widget/react-bridge-bootstrap.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,0BAA0B,8tFAoDtC,CAAC"}
+{"version":3,"file":"react-bridge-bootstrap.d.ts","sourceRoot":"","sources":["../../src/widget/react-bridge-bootstrap.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,0BAA0B,64FAsDtC,CAAC"}

package/node_modules/@noodle-borg/protocol/dist/widget/react-bridge-bootstrap.js

@@ -34,6 +34,7 @@ export const WIDGET_REACT_BRIDGE_SOURCE = `
             pip: modes.includes('pip'),
             openExternal: Boolean(capabilities.openLinks || capabilities.openLink),
             followUpMessage: Boolean(capabilities.message),
+            modelContext: Boolean(capabilities.updateModelContext || capabilities.modelContext),
           },
         };
       },
@@ -47,6 +48,7 @@ export const WIDGET_REACT_BRIDGE_SOURCE = `
         role: 'user',
         content: [{ type: 'text', text: String((message && message.prompt) || '') }],
       }),
+      updateModelContext: (update) => app.updateModelContext(update || {}),
       requestDisplayMode: (mode) => app.requestDisplayMode({ mode }),
     };
     notifyReact('noodle:bridge');

package/node_modules/@noodle-borg/protocol/dist/widget/react-bridge-bootstrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"react-bridge-bootstrap.js","sourceRoot":"","sources":["../../src/widget/react-bridge-bootstrap.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDzC,CAAC"}
+{"version":3,"file":"react-bridge-bootstrap.js","sourceRoot":"","sources":["../../src/widget/react-bridge-bootstrap.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDzC,CAAC"}

package/node_modules/@noodle-borg/runtime/dist/ambient-context.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeArtifact } from '@noodle-borg/compiler';
+import { type ExecuteDeps } from './execute.js';
+import type { ExecutionResult } from './result.js';
+/**
+ * Resolve the server's declared ambient context against the invocation's temporal/caller snapshot.
+ * The provider is compiled fulfilment data, not tenant code, and its result is validated before it can
+ * become `${context.ambient}` for later executions.
+ */
+export declare function executeAmbientContext(artifact: RuntimeArtifact, deps: ExecuteDeps): Promise<ExecutionResult>;
+//# sourceMappingURL=ambient-context.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/ambient-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-context.d.ts","sourceRoot":"","sources":["../src/ambient-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EACL,KAAK,WAAW,EAIjB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,eAAe,CAAC,CAoD1B"}

package/node_modules/@noodle-borg/runtime/dist/ambient-context.js

@@ -0,0 +1,51 @@
+import { canonicalizeContext } from './context-bounds.js';
+import { runFulfilment, splitResultMeta, validateAgainstSchema, } from './execute.js';
+/**
+ * Resolve the server's declared ambient context against the invocation's temporal/caller snapshot.
+ * The provider is compiled fulfilment data, not tenant code, and its result is validated before it can
+ * become `${context.ambient}` for later executions.
+ */
+export async function executeAmbientContext(artifact, deps) {
+    if (artifact.resolution !== 'resolved') {
+        return {
+            ok: false,
+            error: {
+                code: 'shape_only_artifact',
+                message: 'runtime refuses to serve a shape-only artifact',
+            },
+        };
+    }
+    const ambient = artifact.server.context?.ambient;
+    if (ambient === undefined)
+        return { ok: true, output: undefined };
+    const providerContext = deps.context === undefined
+        ? undefined
+        : {
+            temporal: deps.context.temporal,
+            ambientStatus: 'not_configured',
+        };
+    const providerDeps = {
+        ...deps,
+        ...(providerContext !== undefined ? { context: providerContext } : {}),
+    };
+    const result = await runFulfilment(ambient.fulfilment, {}, 'server.context.ambient', providerDeps);
+    if (!result.ok)
+        return result;
+    const { visible } = splitResultMeta(result.output);
+    const canonical = canonicalizeContext(visible);
+    if (!canonical.ok) {
+        return {
+            ok: false,
+            error: {
+                code: 'output_invalid',
+                message: canonical.issue.message,
+                path: canonical.issue.path,
+            },
+        };
+    }
+    const outputError = validateAgainstSchema(canonical.value, ambient.outputSchema, 'context.ambient', 'output_invalid', 'ambient context');
+    if (outputError !== null)
+        return { ok: false, error: outputError };
+    return { ok: true, output: canonical.value };
+}
+//# sourceMappingURL=ambient-context.js.map

package/node_modules/@noodle-borg/runtime/dist/ambient-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ambient-context.js","sourceRoot":"","sources":["../src/ambient-context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAEL,aAAa,EACb,eAAe,EACf,qBAAqB,GACtB,MAAM,cAAc,CAAC;AAGtB;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,QAAyB,EACzB,IAAiB;IAEjB,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QACvC,OAAO;YACL,EAAE,EAAE,KAAK;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,qBAAqB;gBAC3B,OAAO,EAAE,gDAAgD;aAC1D;SACF,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IACjD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IAElE,MAAM,eAAe,GACnB,IAAI,CAAC,OAAO,KAAK,SAAS;QACxB,CAAC,CAAC,SAAS;QACX,CAAC,CAAC;YACE,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC/B,aAAa,EAAE,gBAAyB;SACzC,CAAC;IACR,MAAM,YAAY,GAAgB;QAChC,GAAG,IAAI;QACP,GAAG,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACvE,CAAC;IACF,MAAM,MAAM,GAAG,MAAM,aAAa,CAChC,OAAO,CAAC,UAAU,EAClB,EAAE,EACF,wBAAwB,EACxB,YAAY,CACb,CAAC;IACF,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,OAAO,MAAM,CAAC;IAC9B,MAAM,EAAE,OAAO,EAAE,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACnD,MAAM,SAAS,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAC/C,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;QAClB,OAAO;YACL,EAAE,EAAE,KAAK;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,gBAAgB;gBACtB,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO;gBAChC,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI;aAC3B;SACF,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GAAG,qBAAqB,CACvC,SAAS,CAAC,KAAK,EACf,OAAO,CAAC,YAAY,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,CAClB,CAAC;IACF,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IACnE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC;AAC/C,CAAC"}

package/node_modules/@noodle-borg/runtime/dist/confirmation.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeArtifact } from '@noodle-borg/compiler';
+import { type ExecuteDeps } from './execute.js';
+import type { ConfirmationPreparationResult, ElicitationResponse, InteractiveExecutionResult, PreparedToolContinuation, ToolPreparationContinuation } from './result.js';
+/**
+ * Evaluate the pure prefix of a confirmable tool. Connector operations are an absolute suspension
+ * boundary: this function either requests input, returns a prepared confirmation, or fails before
+ * invoking one.
+ */
+export declare function prepareToolForConfirmation(artifact: RuntimeArtifact, toolName: string, input: unknown, deps: ExecuteDeps): Promise<ConfirmationPreparationResult>;
+/** Resume the pure preparation prefix with one accepted, declined, or cancelled input response. */
+export declare function resumeToolPreparation(artifact: RuntimeArtifact, continuation: ToolPreparationContinuation, response: ElicitationResponse, deps: ExecuteDeps): Promise<ConfirmationPreparationResult>;
+/**
+ * Execute a previously prepared tool after approval. The whole flow is checked again before the
+ * first operation; a forged or drifted continuation can therefore never reach a late elicitation
+ * after performing a side effect.
+ */
+export declare function executePreparedTool(artifact: RuntimeArtifact, continuation: PreparedToolContinuation, deps: ExecuteDeps): Promise<InteractiveExecutionResult>;
+//# sourceMappingURL=confirmation.d.ts.map

package/node_modules/@noodle-borg/runtime/dist/confirmation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirmation.d.ts","sourceRoot":"","sources":["../src/confirmation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGjF,OAAO,EAGL,KAAK,WAAW,EAOjB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAEV,6BAA6B,EAC7B,mBAAmB,EAEnB,0BAA0B,EAE1B,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,aAAa,CAAC;AAIrB;;;;GAIG;AACH,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,6BAA6B,CAAC,CAuBxC;AAED,mGAAmG;AACnG,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,2BAA2B,EACzC,QAAQ,EAAE,mBAAmB,EAC7B,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,6BAA6B,CAAC,CAoCxC;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,wBAAwB,EACtC,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,0BAA0B,CAAC,CAsErC"}