@zackbart/connecta 0.18.2 → 0.19.0

package/dist/execute.js

@@ -4,7 +4,7 @@ import { boundedDiscoveryText, CatalogService, DiscoveryPolicyError, flatSearchR
 import { errorResult, jsonResult } from "./meta-tools.js";
 import { guardExecuteResultValue, MAX_EXECUTE_LOG_CHARS, truncateExecuteText, } from "./executor-result.js";
 import { ExecutorAdmissionError, ExecutorExecutionError, isAdmittingExecutor, } from "./executor-admission.js";
-import { boundedEchoText, classifyCallError } from "./errors.js";
+import { boundedEchoText, classifyCallError, msg } from "./errors.js";
 import { InvocationFailure, InvocationService, } from "./invocation.js";
 import { hasConnectorGuides } from "./skills.js";
 import { isExplicitlyReadOnly } from "./tool-safety.js";
@@ -306,15 +306,19 @@ export class EmitCollector {
      * complaint about its type would send the author to fix the wrong thing.
      */
     acceptUi(...values) {
-        if (this.ui) {
-            throw guestFailure("invalid_args", "connecta.ui accepts at most one payload per run: a view was already accepted and stands");
-        }
+        this.assertUiVacant();
         this.acceptUiPayload(requireUiPayload(values));
     }
-    acceptUiPayload(payload) {
+    acceptValidatedUi(payload) {
+        this.assertUiVacant();
+        this.acceptUiPayload(payload);
+    }
+    assertUiVacant() {
         if (this.ui) {
             throw guestFailure("invalid_args", "connecta.ui accepts at most one payload per run: a view was already accepted and stands");
         }
+    }
+    acceptUiPayload(payload) {
         let serialized;
         try {
             serialized = JSON.stringify(payload);
@@ -429,9 +433,6 @@ const SANDBOX_RESERVED_NAMES = new Set([
     "__stringifyForCodemode",
     "__parseForCodemode",
 ]);
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function guestFailure(code, message, retryable = false) {
     return new InvocationFailure({ code, message, retryable });
 }
@@ -515,13 +516,9 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
         requestScope,
         // A program that just missed an address cannot call search_tools.
         searchRoute: "connecta.search",
-        ...(limits.discoveryConcurrency !== undefined
-            ? { concurrency: limits.discoveryConcurrency }
-            : {}),
-        ...(limits.probeTimeoutMs !== undefined
-            ? { probeTimeoutMs: limits.probeTimeoutMs }
-            : {}),
-        ...(limits.defer !== undefined ? { defer: limits.defer } : {}),
+        concurrency: limits.discoveryConcurrency,
+        probeTimeoutMs: limits.probeTimeoutMs,
+        defer: limits.defer,
     });
     const invocation = new InvocationService(registry, catalog, activity);
     const maxHostCalls = Math.max(1, Math.trunc(limits.maxHostCalls ?? EXECUTE_MAX_HOST_CALLS));
@@ -573,23 +570,30 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
             throw err;
         }
     };
-    const callAddress = async (address, args, diagnosticOperation = "call") => {
-        const outcome = await invocation.invoke(String(address), args ?? {}, invocationContext());
-        limits.diagnostics?.recordCall(diagnosticOperation, outcome);
-        if (!outcome.ok) {
-            const failure = new InvocationFailure(outcome.error);
-            throw failure;
+    const timedCatalog = async (operation, fn) => {
+        const started = Date.now();
+        try {
+            const result = await fn();
+            limits.diagnostics?.recordCatalog(operation, Date.now() - started, true, result);
+            return result;
         }
+        catch (err) {
+            limits.diagnostics?.recordCatalog(operation, Date.now() - started, false);
+            throw err;
+        }
+    };
+    const called = async (operation, invoke) => {
+        const outcome = await invoke();
+        limits.diagnostics?.recordCall(operation, outcome);
+        if (!outcome.ok)
+            throw new InvocationFailure(outcome.error);
         return outcome.value;
     };
+    const callAddress = async (address, args, diagnosticOperation = "call") => {
+        return called(diagnosticOperation, () => invocation.invoke(String(address), args ?? {}, invocationContext()));
+    };
     const callNamespace = async (connectorId, toolAlias, args) => {
-        const outcome = await invocation.invokeToolAlias(String(connectorId), String(toolAlias), sanitizeIdentifier, args ?? {}, invocationContext());
-        limits.diagnostics?.recordCall("call", outcome);
-        if (!outcome.ok) {
-            const failure = new InvocationFailure(outcome.error);
-            throw failure;
-        }
-        return outcome.value;
+        return called("call", () => invocation.invokeToolAlias(String(connectorId), String(toolAlias), sanitizeIdentifier, args ?? {}, invocationContext()));
     };
     /**
      * A read binding is admitted while the program still owns the request. The
@@ -643,7 +647,7 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
                 throw guestFailure("unavailable", "connecta.ui is unavailable: no emission collector was configured for this execution", true);
             }
             const payload = await validateUiReads(requireUiPayload(values));
-            limits.emitCollector.acceptUiPayload(payload);
+            limits.emitCollector.acceptValidatedUi(payload);
         },
         batch: async (calls) => {
             const started = Date.now();
@@ -684,43 +688,21 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
                 throw err;
             }
         },
-        search: async (raw) => {
-            const started = Date.now();
-            try {
-                const result = await typedDiscovery(async () => {
-                    const args = (raw ?? {});
-                    const result = flatSearchResult(await catalog.search({
-                        ...args,
-                        includeSchemaKeys: args.includeSchemaKeys !== false,
-                    }));
-                    boundedDiscoveryText(result, "Request a smaller limit, omit fullDescriptions, use compact schemas, or pass includeSchemaKeys: false.");
-                    return result;
-                });
-                limits.diagnostics?.recordCatalog("search", Date.now() - started, true, result);
-                return result;
-            }
-            catch (err) {
-                limits.diagnostics?.recordCatalog("search", Date.now() - started, false);
-                throw err;
-            }
-        },
-        describe: async (raw) => {
-            const started = Date.now();
-            try {
-                const result = await typedDiscovery(async () => {
-                    const args = (raw ?? {});
-                    const result = { tools: await catalog.describe(args) };
-                    boundedDiscoveryText(result, 'Split the address list or use format: "compact".');
-                    return result;
-                });
-                limits.diagnostics?.recordCatalog("describe", Date.now() - started, true, result);
-                return result;
-            }
-            catch (err) {
-                limits.diagnostics?.recordCatalog("describe", Date.now() - started, false);
-                throw err;
-            }
-        },
+        search: async (raw) => timedCatalog("search", () => typedDiscovery(async () => {
+            const args = (raw ?? {});
+            const result = flatSearchResult(await catalog.search({
+                ...args,
+                includeSchemaKeys: args.includeSchemaKeys !== false,
+            }));
+            boundedDiscoveryText(result, "Request a smaller limit, omit fullDescriptions, use compact schemas, or pass includeSchemaKeys: false.");
+            return result;
+        })),
+        describe: async (raw) => timedCatalog("describe", () => typedDiscovery(async () => {
+            const args = (raw ?? {});
+            const result = { tools: await catalog.describe(args) };
+            boundedDiscoveryText(result, 'Split the address list or use format: "compact".');
+            return result;
+        })),
     };
     const transportedFns = Object.fromEntries(Object.entries(fns).map(([name, fn]) => [
         name,
@@ -790,13 +772,9 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                     },
                     emitCollector: emitted,
                     ...(diagnostics ? { diagnostics } : {}),
-                    ...(config.discoveryConcurrency !== undefined
-                        ? { discoveryConcurrency: config.discoveryConcurrency }
-                        : {}),
-                    ...(config.probeTimeoutMs !== undefined
-                        ? { probeTimeoutMs: config.probeTimeoutMs }
-                        : {}),
-                    ...(config.defer !== undefined ? { defer: config.defer } : {}),
+                    discoveryConcurrency: config.discoveryConcurrency,
+                    probeTimeoutMs: config.probeTimeoutMs,
+                    defer: config.defer,
                 });
             }
             finally {
@@ -826,8 +804,10 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                         retryAfterMs: err.retryAfterMs,
                     });
                 }
-                const result = jsonResult({
-                    error: {
+                return failureResponse(err.message, {
+                    emitted: err instanceof ExecutorExecutionError ? emitted : undefined,
+                    diagnostics,
+                    code: {
                         code: err.code,
                         message: err.message,
                         retryable: err.retryable,
@@ -835,28 +815,13 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                             ? { retryAfterMs: err.retryAfterMs }
                             : {}),
                     },
-                    ...(err instanceof ExecutorExecutionError
-                        ? discardedEmits(emitted)
-                        : {}),
-                    ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
                 });
-                result.isError = true;
-                return result;
             }
-            if (diagnostics) {
-                const result = jsonResult({
-                    error: {
-                        code: "executor_failed",
-                        message: `Executor failed: ${msg(err)}`,
-                        retryable: false,
-                    },
-                    ...discardedEmits(emitted),
-                    diagnostics: diagnostics.finish(),
-                });
-                result.isError = true;
-                return result;
-            }
-            return errorResult(`Executor failed: ${msg(err)}${discardedEmitsText(emitted)}`);
+            return failureResponse(`Executor failed: ${msg(err)}`, {
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
         }
         finally {
             // A sandbox timeout or early return must also release any outstanding
@@ -900,31 +865,20 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
                 // framed with bounded caller text (`boundedEchoText`) precisely so
                 // this path never needs one. Adding a cap here instead would leave the
                 // top-level surfaces, which have the same amplification, uncovered.
-                const result = jsonResult({
-                    error: invocationFailure.details,
-                    ...(logs ? { logs } : {}),
-                    ...discardedEmits(emitted),
-                    ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
+                return failureResponse(invocationFailure.details.message, {
+                    logs,
+                    emitted,
+                    diagnostics,
+                    code: invocationFailure.details,
                 });
-                result.isError = true;
-                return result;
             }
             const message = `Error: ${outcome.error}`;
-            if (diagnostics) {
-                const result = jsonResult({
-                    error: {
-                        code: "executor_failed",
-                        message,
-                        retryable: false,
-                    },
-                    ...(logs ? { logs } : {}),
-                    ...discardedEmits(emitted),
-                    diagnostics: diagnostics.finish(),
-                });
-                result.isError = true;
-                return result;
-            }
-            return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${discardedEmitsText(emitted)}`);
+            return failureResponse(message, {
+                logs,
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
         }
         // A result crossing back as a host BigInt (or otherwise unserializable
         // value) makes JSON.stringify throw — keep that inside the structured
@@ -935,21 +889,12 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
         }
         catch (err) {
             const message = `Error: result is not JSON-serializable: ${msg(err)}`;
-            if (diagnostics) {
-                const response = jsonResult({
-                    error: {
-                        code: "executor_failed",
-                        message,
-                        retryable: false,
-                    },
-                    ...(logs ? { logs } : {}),
-                    ...discardedEmits(emitted),
-                    diagnostics: diagnostics.finish(),
-                });
-                response.isError = true;
-                return response;
-            }
-            return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${discardedEmitsText(emitted)}`);
+            return failureResponse(message, {
+                logs,
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
         }
         const response = jsonResult({
             result,
@@ -976,6 +921,22 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
         return response;
     };
 }
+function failureResponse(message, options) {
+    const { logs, emitted, diagnostics, code } = options;
+    if (diagnostics || typeof code !== "string") {
+        const result = jsonResult({
+            error: typeof code === "string"
+                ? { code, message, retryable: false }
+                : code,
+            ...(logs ? { logs } : {}),
+            ...(emitted ? discardedEmits(emitted) : {}),
+            ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
+        });
+        result.isError = true;
+        return result;
+    }
+    return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${emitted ? discardedEmitsText(emitted) : ""}`);
+}
 /**
  * M4 and U3: a failed program delivers no blocks and no view, but each
  * discard is visible — and one failure can discard both.
@@ -1049,15 +1010,11 @@ export function registerExecuteTool(server, registry, ctx) {
     };
     const connectors = registry.listConnectors();
     const handler = createExecuteTool(registry, ctx.baseUrl, ctx.executor, ctx.logger, ctx.activity, {
-        ...(ctx.discoveryConcurrency !== undefined
-            ? { discoveryConcurrency: ctx.discoveryConcurrency }
-            : {}),
-        ...(ctx.probeTimeoutMs !== undefined
-            ? { probeTimeoutMs: ctx.probeTimeoutMs }
-            : {}),
+        discoveryConcurrency: ctx.discoveryConcurrency,
+        probeTimeoutMs: ctx.probeTimeoutMs,
         maxEmittedBytes: emitBudgets.maxBytes,
         maxEmittedBlocks: emitBudgets.maxBlocks,
-        ...(ctx.defer !== undefined ? { defer: ctx.defer } : {}),
+        defer: ctx.defer,
     });
     server.registerTool("execute_code", {
         description: executeDescription(emitBudgets, hasConnectorGuides(connectors), connectors),
@@ -1078,12 +1035,8 @@ export function registerExecuteTool(server, registry, ctx) {
             destructiveHint: false,
             openWorldHint: true,
         },
-        // U5 and U10: declared unconditionally. A host without the Apps
-        // extension ignores unknown _meta and sees the ordinary envelope, which
-        // is the text fallback the spec mandates — and a stateless aggregator
-        // has nowhere dependable to hold a negotiation check anyway. The
-        // explicit visibility keeps hosts from being told the view may call
-        // execute_code; the default ["model","app"] would say exactly that.
+        // U5 and U10 are specified in documentation/code-mode.md; explicit model
+        // visibility prevents hosts from offering execute_code to the view.
         _meta: {
             ui: {
                 resourceUri: PROGRAM_UI_RESOURCE_URI,

package/dist/executor-result.d.ts

@@ -1,5 +1,6 @@
 import type { ExecuteResult } from "./types.js";
 export declare const MAX_EXECUTE_LOG_CHARS = 4000;
+export declare function serializeResultText(value: unknown): string;
 export declare function guardExecuteResultValue(value: unknown): unknown;
 export declare function truncateExecuteText(text: string, max: number): string;
 /**

package/dist/executor-result.js

@@ -1,10 +1,8 @@
+import { msg } from "./errors.js";
 /** ~6k tokens. Sandbox code should filter data down before returning. */
 const MAX_EXECUTE_RESULT_CHARS = 24_000;
 export const MAX_EXECUTE_LOG_CHARS = 4_000;
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-function serializeExecuteValue(value) {
+export function serializeResultText(value) {
     const serialized = JSON.stringify(value);
     return serialized === undefined ? String(value) : serialized;
 }
@@ -37,15 +35,10 @@ function truncationEnvelope(text) {
         // the overshoot ratio (minus a step) strictly shrinks the budget.
         budget = Math.max(0, Math.floor(budget * (MAX_EXECUTE_RESULT_CHARS / size)) - 8);
     }
-    // The loop shrinks monotonically, so this is unreachable in practice — but an
-    // unchecked slice is exactly how a "bounded" envelope stops being bounded.
-    const clamped = { ...base, preview: text.slice(0, Math.max(0, budget)) };
-    return JSON.stringify(clamped).length <= MAX_EXECUTE_RESULT_CHARS
-        ? clamped
-        : { ...base, preview: "" };
+    return { ...base, preview: text.slice(0, budget) };
 }
 export function guardExecuteResultValue(value) {
-    const text = serializeExecuteValue(value);
+    const text = serializeResultText(value);
     if (text.length <= MAX_EXECUTE_RESULT_CHARS)
         return value;
     return truncationEnvelope(text);

package/dist/executors/quickjs-child.js

@@ -1,12 +1,10 @@
 import { prepareExecuteResultForTransport } from "../executor-result.js";
+import { msg } from "../errors.js";
 import { MAX_QUICKJS_IPC_BYTES, MAX_QUICKJS_HOST_RPC_BYTES, serializedBytes, stringifyBounded, } from "./quickjs-protocol.js";
 import { executeQuickJs, prepareQuickJs } from "./quickjs-runtime.js";
 let activeJobId;
 let nextCallId = 1;
 const pending = new Map();
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function send(message) {
     if (!process.send)
         throw new Error("QuickJS child IPC channel is unavailable.");

package/dist/executors/quickjs-runtime.js

@@ -8,6 +8,7 @@
 // continuations from a host-side loop. Values cross the boundary as JSON, so
 // provider args/results must be JSON-serializable.
 import { getQuickJS, } from "quickjs-emscripten";
+import { msg } from "../errors.js";
 import { hostCallLabel, MAX_QUICKJS_LOG_TRANSPORT_BYTES, serializedBytes, } from "./quickjs-protocol.js";
 /** Load and compile the shared QuickJS WASM module before a run budget starts. */
 export async function prepareQuickJs() {
@@ -29,9 +30,6 @@ const MAX_LOG_MARKER_TRANSPORT_BYTES = Math.max(logTransportBytes(LOG_ENTRY_LIMI
 // This still lets guest code reduce data more than ten times larger than
 // connecta's final response budget.
 const MAX_HOST_RESULT_BYTES = 256 * 1024;
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function logTransportBytes(entry) {
     // The log is encoded into ExecutionPayload, then that payloadJson string is
     // encoded into ChildToParentMessage. Measure the units the IPC cap sees.

package/dist/executors/quickjs.js

@@ -6,6 +6,7 @@ import { fork } from "node:child_process";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { AdmissionController, ExecutorAdmissionError, ExecutorExecutionError, } from "../executor-admission.js";
+import { msg } from "../errors.js";
 import { hostCallLabel, MAX_QUICKJS_IPC_BYTES, MAX_QUICKJS_HOST_RPC_BYTES, serializedBytes, stringifyBounded, } from "./quickjs-protocol.js";
 export { normalizeCode } from "./quickjs-runtime.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -19,9 +20,6 @@ const CHILD_EXIT_GRACE_MS = 250;
 const CHILD_STARTUP_TIMEOUT_MS = 10_000;
 const MAX_CHILD_STDERR_BYTES = 8 * 1024;
 const MAX_ERROR_CHARS = 4_000;
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
 function retainStderrTail(current, chunk) {
     const incoming = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
     if (incoming.length >= MAX_CHILD_STDERR_BYTES) {

package/dist/index.js

@@ -194,7 +194,7 @@ function warnInsecureConfig(config, inboundAuth, logger) {
 }
 export function createConnecta(config) {
     assertNoLegacyConfig(config);
-    if (Object.prototype.hasOwnProperty.call(config, "surface")) {
+    if (hasOwn(config, "surface")) {
         throw new Error("ConnectaConfig.surface was removed in issue #273. Remove it; connecta " +
             "now serves one seven-tool surface.");
     }
@@ -233,30 +233,20 @@ export function createConnecta(config) {
     const registry = new Registry(config.connectors, {
         storage,
         logger,
-        ...(credentialVault !== undefined ? { credentialVault } : {}),
-        ...(config.activity?.store !== undefined
+        credentialVault,
+        catalogDriftActivity: config.activity?.store
             ? {
-                catalogDriftActivity: {
-                    sink: config.activity.store,
-                    serverInfo,
-                    ...(config.activity.deploymentId !== undefined
-                        ? { deploymentId: config.activity.deploymentId }
-                        : {}),
-                },
+                sink: config.activity.store,
+                serverInfo,
+                ...(config.activity.deploymentId !== undefined
+                    ? { deploymentId: config.activity.deploymentId }
+                    : {}),
             }
-            : {}),
-        ...(config.discovery?.catalogTtlSeconds !== undefined
-            ? { toolCacheTtlSeconds: config.discovery.catalogTtlSeconds }
-            : {}),
-        ...(config.discovery?.persistCatalog !== undefined
-            ? { persistToolCatalog: config.discovery.persistCatalog }
-            : {}),
-        ...(config.discovery?.staleCatalogSeconds !== undefined
-            ? { toolCatalogStaleSeconds: config.discovery.staleCatalogSeconds }
-            : {}),
-        ...(config.calls?.maxResultBytes !== undefined
-            ? { maxResultBytes: config.calls.maxResultBytes }
-            : {}),
+            : undefined,
+        toolCacheTtlSeconds: config.discovery?.catalogTtlSeconds,
+        persistToolCatalog: config.discovery?.persistCatalog,
+        toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
+        maxResultBytes: config.calls?.maxResultBytes,
     });
     const inboundAuth = normalizeAuth(accessTokens ? [accessTokens.auth, ...configuredAuth] : configuredAuth);
     warnInsecureConfig(config, inboundAuth, logger);
@@ -279,44 +269,24 @@ export function createConnecta(config) {
     const handler = createFetchHandler({
         registry,
         auth: inboundAuth,
-        ...(config.publicUrl !== undefined ? { publicUrl: config.publicUrl } : {}),
+        publicUrl: config.publicUrl,
         serverInfo,
         logger,
-        ...(config.activity?.store !== undefined
-            ? { activity: config.activity.store }
-            : {}),
-        ...(config.activity?.readGate !== undefined
-            ? { activityReadGate: config.activity.readGate }
-            : {}),
-        ...(config.activity?.deploymentId !== undefined
-            ? { activityDeploymentId: config.activity.deploymentId }
-            : {}),
+        activity: config.activity?.store,
+        activityReadGate: config.activity?.readGate,
+        activityDeploymentId: config.activity?.deploymentId,
         executor,
-        ...(configuredExecutorName !== undefined
-            ? { executorName: configuredExecutorName }
-            : {}),
+        executorName: configuredExecutorName,
         requestAdmission,
-        ...(config.calls?.defaultTimeoutMs !== undefined
-            ? { defaultToolTimeoutMs: config.calls.defaultTimeoutMs }
-            : {}),
-        ...(config.discovery?.probeTimeoutMs !== undefined
-            ? { probeTimeoutMs: config.discovery.probeTimeoutMs }
-            : {}),
-        ...(config.discovery?.concurrency !== undefined
-            ? { discoveryConcurrency: config.discovery.concurrency }
-            : {}),
-        ...(config.execute?.maxEmittedBytes !== undefined
-            ? { maxEmittedBytes: config.execute.maxEmittedBytes }
-            : {}),
-        ...(config.execute?.maxEmittedBlocks !== undefined
-            ? { maxEmittedBlocks: config.execute.maxEmittedBlocks }
-            : {}),
-        ...(credentialVault !== undefined ? { credentialVault } : {}),
-        ...(accessTokens !== undefined ? { accessTokens } : {}),
-        ...(config.deploymentInfo !== undefined
-            ? { deploymentInfo: config.deploymentInfo }
-            : {}),
-        ...(config.branding !== undefined ? { branding: config.branding } : {}),
+        defaultToolTimeoutMs: config.calls?.defaultTimeoutMs,
+        probeTimeoutMs: config.discovery?.probeTimeoutMs,
+        discoveryConcurrency: config.discovery?.concurrency,
+        maxEmittedBytes: config.execute?.maxEmittedBytes,
+        maxEmittedBlocks: config.execute?.maxEmittedBlocks,
+        credentialVault,
+        accessTokens,
+        deploymentInfo: config.deploymentInfo,
+        branding: config.branding,
     });
     let closePromise;
     return {