@moxt-ai/mobius 0.0.302 → 0.0.303

package/dist/runtime.js

@@ -21002,6 +21002,37 @@ var runtimeUpgradeResultSchema = external_exports.strictObject({
 var decodeRuntimeUpgradeResult = (raw) => runtimeUpgradeResultSchema.parse(JSON.parse(raw));
 var encodeRuntimeUpgradeResult = (value) => JSON.stringify(runtimeUpgradeResultSchema.parse(value));
 
+// ../mobius-sdk/src/protocol/session/agent/catalog.ts
+var AGENT_CATALOG_DISCOVER_KIND = "agent.catalog.discover";
+var AGENT_CATALOG_DISCOVERED_KIND = "agent.catalog.discovered";
+var AGENT_CATALOG_DISCOVERY_FAILED_KIND = "agent.catalog.discovery.failed";
+var catalogedAgentSchema = external_exports.object({
+  agentVersion: external_exports.string().min(1).max(128),
+  id: identifierStringSchema,
+  label: external_exports.string().min(1).max(255)
+}).readonly();
+var agentCatalogDiscoverCommandSchema = external_exports.object({
+  kind: external_exports.literal(AGENT_CATALOG_DISCOVER_KIND),
+  requestId: identifierStringSchema
+}).readonly();
+var agentCatalogDiscoveredEventSchema = external_exports.object({
+  agents: external_exports.array(catalogedAgentSchema).max(64).readonly(),
+  kind: external_exports.literal(AGENT_CATALOG_DISCOVERED_KIND),
+  requestId: identifierStringSchema
+}).readonly();
+var agentCatalogDiscoveryFailedEventSchema = external_exports.object({
+  code: identifierStringSchema,
+  kind: external_exports.literal(AGENT_CATALOG_DISCOVERY_FAILED_KIND),
+  message: external_exports.string().min(1).max(500),
+  requestId: identifierStringSchema
+}).readonly();
+var decodeAgentCatalogDiscoverCommand = (encoded) => decodeZodMessage(encoded, agentCatalogDiscoverCommandSchema);
+var encodeAgentCatalogDiscoverCommand = (message) => encodeZodMessage(message, agentCatalogDiscoverCommandSchema);
+var decodeAgentCatalogDiscoveredEvent = (encoded) => decodeZodMessage(encoded, agentCatalogDiscoveredEventSchema);
+var encodeAgentCatalogDiscoveredEvent = (message) => encodeZodMessage(message, agentCatalogDiscoveredEventSchema);
+var decodeAgentCatalogDiscoveryFailedEvent = (encoded) => decodeZodMessage(encoded, agentCatalogDiscoveryFailedEventSchema);
+var encodeAgentCatalogDiscoveryFailedEvent = (message) => encodeZodMessage(message, agentCatalogDiscoveryFailedEventSchema);
+
 // ../mobius-sdk/src/protocol/session/shared/index.ts
 var SHORT_TEXT = external_exports.string().max(500);
 var workspaceEntrySchema = external_exports.object({
@@ -22410,6 +22441,11 @@ var serviceToDaemonSignatures = {
     encodeAgentSettingsDiscoverCommand,
     decodeAgentSettingsDiscoverCommand
   ),
+  [AGENT_CATALOG_DISCOVER_KIND]: defineMessageSignature(
+    AGENT_CATALOG_DISCOVER_KIND,
+    encodeAgentCatalogDiscoverCommand,
+    decodeAgentCatalogDiscoverCommand
+  ),
   [FILE_READ_KIND]: defineMessageSignature(FILE_READ_KIND, encodeFileReadCommand, decodeFileReadCommand),
   [SESSION_LIST_KIND]: defineMessageSignature(SESSION_LIST_KIND, encodeSessionListCommand, decodeSessionListCommand),
   [SESSION_QUERY_KIND]: defineMessageSignature(
@@ -22559,6 +22595,16 @@ var daemonToServiceSignatures = {
     encodeAgentSettingsDiscoveryFailedEvent,
     decodeAgentSettingsDiscoveryFailedEvent
   ),
+  [AGENT_CATALOG_DISCOVERED_KIND]: defineMessageSignature(
+    AGENT_CATALOG_DISCOVERED_KIND,
+    encodeAgentCatalogDiscoveredEvent,
+    decodeAgentCatalogDiscoveredEvent
+  ),
+  [AGENT_CATALOG_DISCOVERY_FAILED_KIND]: defineMessageSignature(
+    AGENT_CATALOG_DISCOVERY_FAILED_KIND,
+    encodeAgentCatalogDiscoveryFailedEvent,
+    decodeAgentCatalogDiscoveryFailedEvent
+  ),
   [FILE_BEGIN_KIND]: defineMessageSignature(FILE_BEGIN_KIND, encodeFileBeginEvent, decodeFileBeginEvent),
   [FILE_CHUNK_KIND]: defineMessageSignature(FILE_CHUNK_KIND, encodeFileChunkEvent, decodeFileChunkEvent),
   [FILE_END_KIND]: defineMessageSignature(FILE_END_KIND, encodeFileEndEvent, decodeFileEndEvent),
@@ -22641,7 +22687,7 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.302",
+  version: "0.0.303",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -74125,6 +74171,20 @@ async function publishAgentCatalog(config2, signal) {
 // src/runtime/config.ts
 import { join as join20, resolve as resolve13 } from "node:path";
 
+// src/util/serial-task-queue.ts
+var SerialTaskQueue = class {
+  #tail = Promise.resolve();
+  run = async (task, signal) => {
+    signal.throwIfAborted();
+    const result = this.#tail.then(() => {
+      signal.throwIfAborted();
+      return task(signal);
+    });
+    this.#tail = result.catch(() => void 0);
+    return await result;
+  };
+};
+
 // src/agent/catalog.ts
 var LocalAgentCatalogSnapshot = class {
   agents;
@@ -74140,6 +74200,7 @@ var LocalAgentCatalogError = class extends OperationError {
 };
 var LocalAgentCatalog = class {
   #snapshot;
+  #updates = new SerialTaskQueue();
   constructor(agents) {
     this.#snapshot = this.validate(agents);
   }
@@ -74152,10 +74213,20 @@ var LocalAgentCatalog = class {
     throw new LocalAgentCatalogError();
   };
   read = () => this.#snapshot;
-  transition = (agents) => {
-    const next = this.validate(agents);
-    this.#snapshot = next;
-    return next;
+  /** Serializes replacements and publication; a failed publication restores only its own prior snapshot. */
+  replaceAndPublish = async (build, publish, signal) => {
+    return await this.#updates.run(async (updateSignal) => {
+      const previous = this.#snapshot;
+      const next = this.validate(build(previous.agents));
+      this.#snapshot = next;
+      try {
+        await publish(updateSignal);
+      } catch (error62) {
+        this.#snapshot = previous;
+        throw error62;
+      }
+      return next;
+    }, signal);
   };
   validate = (agents) => {
     const identifiers = /* @__PURE__ */ new Set();
@@ -74202,7 +74273,7 @@ var OpaqueRuntimeReconnectTarget = class extends RuntimeReconnectTarget {
     this.commandArgument = `--connection ${connectionId2}`;
   }
 };
-function createRuntimeConfig(connection, agents = [], localContext = new RuntimeLocalContext(readStateDirectory(), process.env), reconnectTarget = null, resolveAgent) {
+function createRuntimeConfig(connection, agents = [], localContext = new RuntimeLocalContext(readStateDirectory(), process.env), reconnectTarget = null, resolveAgent, rediscoverAgents) {
   const runtimeAgents = agents.map((agent) => withRuntimeEnvironment(agent, localContext.environment));
   return {
     agents: runtimeAgents,
@@ -74213,7 +74284,8 @@ function createRuntimeConfig(connection, agents = [], localContext = new Runtime
     localContext,
     reconnectTarget,
     relayUrl: connection.relayUrl,
-    ...resolveAgent === void 0 ? {} : { resolveAgent }
+    ...resolveAgent === void 0 ? {} : { resolveAgent },
+    ...rediscoverAgents === void 0 ? {} : { rediscoverAgents }
   };
 }
 
@@ -74243,21 +74315,17 @@ function createCatalogAgentResolver(discover, readConfig, publish) {
       signal.throwIfAborted();
       const inventory = await discover(signal);
       signal.throwIfAborted();
-      const previous = config2.catalog.read();
-      const previousAgent = previous.agents.find((entry) => entry.id === agent.id);
-      if (previousAgent === void 0) {
-        throw new Error(`The local Agent ${agent.id} left the catalog before its refresh completed`);
-      }
-      config2.catalog.transition([
-        ...previous.agents.filter((entry) => entry.id !== agent.id),
-        ...inventory.readyAgents().filter((ready) => ready.id === agent.id).map((ready) => withRuntimeEnvironment(ready, config2.localContext.environment))
-      ]);
-      try {
-        await publish(config2, signal);
-      } catch (error62) {
-        config2.catalog.transition(previous.agents);
-        throw error62;
-      }
+      const rediscovered = inventory.readyAgents().filter((ready) => ready.id === agent.id).map((ready) => withRuntimeEnvironment(ready, config2.localContext.environment));
+      await config2.catalog.replaceAndPublish(
+        (current) => {
+          if (!current.some((entry) => entry.id === agent.id)) {
+            throw new Error(`The local Agent ${agent.id} left the catalog before its refresh completed`);
+          }
+          return [...current.filter((entry) => entry.id !== agent.id), ...rediscovered];
+        },
+        (publishSignal) => publish(config2, publishSignal),
+        signal
+      );
       return config2.catalog.find(agent.id);
     } finally {
       swaps.delete(agent.id);
@@ -75116,7 +75184,12 @@ function buildPairedRuntime(installation, connection, defaultWorkspace, inventor
       }),
       () => config2,
       publishAgentCatalog
-    )
+    ),
+    (refreshSignal) => discoverLocalAgentInventory({
+      defaultWorkspace,
+      environment: localContext.environment,
+      signal: refreshSignal
+    }).then((inventory2) => inventory2.readyAgents())
   );
   return {
     channelUrl: new URL(`/channels/${encodeURIComponent(connection.channelId)}`, connection.relayOrigin).toString(),
@@ -88173,11 +88246,151 @@ var RelayConnectionDiagnostics = class {
 };
 
 // src/runtime/relay/run-relay-connection.ts
-import { WebSocket as WebSocket7 } from "undici";
+import { WebSocket as WebSocket8 } from "undici";
 
-// src/runtime/command/agent-settings-discovery.ts
+// src/runtime/catalog/handle-agent-catalog-discovery.ts
 import { WebSocket as WebSocket3 } from "undici";
 
+// src/runtime/command/transport.ts
+import { WebSocket as WebSocket2 } from "undici";
+function send(socket, message) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    throw new Error("Relay connection is not open");
+  }
+  socket.send(encodeDaemonToServiceMessage(message));
+}
+function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTimings = []) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    return;
+  }
+  send(socket, {
+    code: operationErrorCode(error62),
+    kind: "session.operation.failed",
+    message: operationErrorMessage(error62),
+    requestId,
+    ...runtimeTimings.length === 0 ? {} : { runtimeTimings },
+    sessionId
+  });
+}
+
+// src/runtime/catalog/handle-agent-catalog-discovery.ts
+var CATALOG_DISCOVERY_TIMEOUT_MILLISECONDS = 9e4;
+function discoveredEvent(command, agents) {
+  return {
+    agents: agents.map((agent) => ({
+      agentVersion: agent.agentVersion,
+      id: agent.id,
+      label: agent.label
+    })),
+    kind: "agent.catalog.discovered",
+    requestId: command.requestId
+  };
+}
+function createAgentCatalogDiscoveryHandler(dependencies) {
+  const { config: config2, discover, diagnostics, socket, signal, timer } = dependencies;
+  const requestIds = /* @__PURE__ */ new Set();
+  let controller = null;
+  let completion = null;
+  const handle = (command) => {
+    if (requestIds.has(command.requestId) || controller !== null) {
+      if (socket.readyState === WebSocket3.OPEN) {
+        send(socket, {
+          code: "agent_catalog_discovery_busy",
+          kind: AGENT_CATALOG_DISCOVERY_FAILED_KIND,
+          message: "An Agent catalog discovery is already running",
+          requestId: command.requestId
+        });
+      }
+      return;
+    }
+    controller = new AbortController();
+    requestIds.add(command.requestId);
+    const operationSignal = AbortSignal.any([signal, controller.signal]);
+    const timeout = timer.schedule(
+      () => controller?.abort(new Error("Agent catalog discovery timed out")),
+      CATALOG_DISCOVERY_TIMEOUT_MILLISECONDS
+    );
+    completion = (async () => {
+      try {
+        const readyAgents = await discover(operationSignal);
+        operationSignal.throwIfAborted();
+        const published = await config2.catalog.replaceAndPublish(
+          () => readyAgents.map((agent) => withRuntimeEnvironment(agent, config2.localContext.environment)),
+          (publishSignal) => publishAgentCatalog(config2, publishSignal),
+          operationSignal
+        );
+        operationSignal.throwIfAborted();
+        if (socket.readyState === WebSocket3.OPEN) {
+          send(
+            socket,
+            discoveredEvent(
+              command,
+              published.agents.map((agent) => ({
+                agentVersion: agent.agentVersion,
+                id: agent.id,
+                label: agent.label
+              }))
+            )
+          );
+        }
+      } catch (error62) {
+        diagnostics.daemonDiagnostic(
+          "agent_catalog_discovery_failed",
+          command.requestId,
+          { code: operationErrorCode(error62) },
+          error62
+        );
+        if (socket.readyState === WebSocket3.OPEN) {
+          send(socket, {
+            code: operationErrorCode(error62),
+            kind: AGENT_CATALOG_DISCOVERY_FAILED_KIND,
+            message: operationErrorMessage(error62),
+            requestId: command.requestId
+          });
+        }
+      } finally {
+        timeout.cancel();
+        requestIds.delete(command.requestId);
+        controller = null;
+        completion = null;
+      }
+    })();
+  };
+  const settle2 = async () => {
+    await (completion ?? Promise.resolve());
+  };
+  return { handle, settle: settle2 };
+}
+
+// src/runtime/command/registry/agent-catalog.ts
+function createAgentCatalogCommands(context) {
+  const handler = createAgentCatalogDiscoveryHandler({
+    config: context.config,
+    discover: context.config.rediscoverAgents === void 0 ? () => {
+      throw new Error("Agent catalog discovery is not available for this Runtime");
+    } : context.config.rediscoverAgents,
+    diagnostics: context.diagnostics,
+    socket: context.socket,
+    signal: context.signal,
+    timer: context.timer
+  });
+  return [
+    {
+      kind: AGENT_CATALOG_DISCOVER_KIND,
+      handle: (_context, message) => {
+        if (message.kind !== AGENT_CATALOG_DISCOVER_KIND) {
+          throw new Error("Command kind mismatch");
+        }
+        handler.handle(message);
+      },
+      settle: handler.settle
+    }
+  ];
+}
+
+// src/runtime/command/agent-settings-discovery.ts
+import { WebSocket as WebSocket4 } from "undici";
+
 // src/session/api/session-error.ts
 var SessionError = class extends OperationError {
   constructor(code, message, options = {}) {
@@ -88513,28 +88726,6 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
   ).digest("hex");
 }
 
-// src/runtime/command/transport.ts
-import { WebSocket as WebSocket2 } from "undici";
-function send(socket, message) {
-  if (socket.readyState !== WebSocket2.OPEN) {
-    throw new Error("Relay connection is not open");
-  }
-  socket.send(encodeDaemonToServiceMessage(message));
-}
-function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTimings = []) {
-  if (socket.readyState !== WebSocket2.OPEN) {
-    return;
-  }
-  send(socket, {
-    code: operationErrorCode(error62),
-    kind: "session.operation.failed",
-    message: operationErrorMessage(error62),
-    requestId,
-    ...runtimeTimings.length === 0 ? {} : { runtimeTimings },
-    sessionId
-  });
-}
-
 // src/runtime/command/agent-settings-discovery.ts
 function createAgentSettingsDiscoveryHandler(dependencies) {
   const { config: config2, directories, sessions, diagnostics, socket, signal, timer } = dependencies;
@@ -88544,7 +88735,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
       (request) => request.agentId === command.agentId && !request.controller.signal.aborted
     );
     if ([...agentSettingsDiscoveries.values()].some((request) => request.requestIds.has(command.requestId))) {
-      if (socket.readyState === WebSocket3.OPEN) {
+      if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
@@ -88559,7 +88750,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
       return;
     }
     if (existing !== void 0) {
-      if (socket.readyState === WebSocket3.OPEN) {
+      if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
@@ -88570,7 +88761,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
       return;
     }
     if (agentSettingsDiscoveries.size >= 4) {
-      if (socket.readyState === WebSocket3.OPEN) {
+      if (socket.readyState === WebSocket4.OPEN) {
         send(socket, {
           code: "agent_settings_discovery_busy",
           kind: AGENT_SETTINGS_DISCOVERY_FAILED_KIND,
@@ -88608,7 +88799,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
           );
         }
         for (const requestId of requestIds) {
-          if (socket.readyState === WebSocket3.OPEN) {
+          if (socket.readyState === WebSocket4.OPEN) {
             send(socket, { ...result.event, requestId });
           }
         }
@@ -88622,7 +88813,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 `
           );
         }
-        if (socket.readyState === WebSocket3.OPEN) {
+        if (socket.readyState === WebSocket4.OPEN) {
           for (const requestId of requestIds) {
             send(socket, {
               code: operationErrorCode(failure2),
@@ -88678,7 +88869,7 @@ function createAgentSettingsCommands(context) {
 }
 
 // src/runtime/command/registry/file-read/index.ts
-import { WebSocket as WebSocket4 } from "undici";
+import { WebSocket as WebSocket5 } from "undici";
 
 // src/session/content/session-files.ts
 import { basename as basename8, extname as extname2, isAbsolute as isAbsolute15, join as join30, normalize as normalize3, resolve as resolve16 } from "node:path";
@@ -88781,7 +88972,7 @@ var fileReadCommand = {
       sessions.findSessions([message.sessionId])[0]?.cwd ?? null,
       externalContent
     ).catch((error62) => {
-      if (socket.readyState !== WebSocket4.OPEN || signal.aborted) {
+      if (socket.readyState !== WebSocket5.OPEN || signal.aborted) {
         return;
       }
       send(socket, {
@@ -89124,7 +89315,7 @@ var elicitationRespondCommand = {
 };
 
 // src/runtime/command/native-session-requests.ts
-import { WebSocket as WebSocket5 } from "undici";
+import { WebSocket as WebSocket6 } from "undici";
 function createNativeSessionRequestHandler(dependencies) {
   const { diagnostics, nativeSessions, signal, socket, timer } = dependencies;
   const pending = /* @__PURE__ */ new Map();
@@ -89176,7 +89367,7 @@ function createNativeSessionRequestHandler(dependencies) {
         }
         operationSignal.throwIfAborted();
         const result = await nativeSessions.execute(command, operationSignal);
-        if (socket.readyState === WebSocket5.OPEN) {
+        if (socket.readyState === WebSocket6.OPEN) {
           send(socket, result);
         }
       } catch (error62) {
@@ -90277,6 +90468,7 @@ function createCommandRegistry(context) {
     sessionHistoryPageLoadCommand,
     previewHistoryPageLoadCommand,
     ...createNativeSessionCommands(context),
+    ...createAgentCatalogCommands(context),
     ...createAgentSettingsCommands(context),
     fileReadCommand,
     sessionCancelCommand,
@@ -90312,7 +90504,7 @@ function createRuntimeCommandDispatcher(options) {
 }
 
 // src/runtime/relay/connect.ts
-import { WebSocket as WebSocket6 } from "undici";
+import { WebSocket as WebSocket7 } from "undici";
 
 // src/runtime/relay/runtime-revocation.ts
 var runtimeRevocationCloseCode = 1008;
@@ -90350,7 +90542,7 @@ function connectRelay(url2, signal) {
     const endpoint = new URL(url2);
     const headers = relayAuthorization(endpoint);
     endpoint.searchParams.delete("token");
-    const socket = new WebSocket6(endpoint, {
+    const socket = new WebSocket7(endpoint, {
       dispatcher: environmentProxyDispatcher,
       headers
     });
@@ -90558,7 +90750,7 @@ function readCommandCorrelation(encoded) {
   };
 }
 function rejectUnsupportedCommand(socket, correlation, rejection) {
-  if (socket.readyState !== WebSocket7.OPEN) {
+  if (socket.readyState !== WebSocket8.OPEN) {
     return;
   }
   send(socket, {
@@ -90606,7 +90798,7 @@ async function runRelayConnection({
     timer
   });
   void reportUpgradeAvailability((result) => {
-    if (socket.readyState === WebSocket7.OPEN) {
+    if (socket.readyState === WebSocket8.OPEN) {
       send(socket, result);
     }
   }, signal).catch((cause) => {
@@ -90657,14 +90849,14 @@ async function runRelayConnection({
       };
       const connectionLiveness = new RelayConnectionLiveness(timer, {
         send: (message) => {
-          if (socket.readyState !== WebSocket7.OPEN) {
+          if (socket.readyState !== WebSocket8.OPEN) {
             return false;
           }
           try {
             send(socket, message);
             return true;
           } catch (error62) {
-            if (socket.readyState !== WebSocket7.OPEN) {
+            if (socket.readyState !== WebSocket8.OPEN) {
               return false;
             }
             throw error62;
@@ -90770,7 +90962,7 @@ async function runRelayConnection({
 }
 
 // src/runtime/relay/session-event-publisher.ts
-import { WebSocket as WebSocket8 } from "undici";
+import { WebSocket as WebSocket9 } from "undici";
 var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
 var MAX_PENDING_BYTES2 = 32 * 1024 * 1024;
 var MAX_EVENT_BATCH_BYTES = 1024 * 1024;
@@ -90820,7 +91012,7 @@ var RuntimeSessionEventPublisher = class {
   publishClosed = (event) => this.#send(event);
   #send = (message) => {
     const connection = this.#connection;
-    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket9.OPEN) {
       return;
     }
     const socket = connection.socket;
@@ -90871,7 +91063,7 @@ var RuntimeSessionEventPublisher = class {
     batch.bytes += bytes;
     this.#pendingBytes += additionalBytes;
     const connection = this.#connection;
-    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket9.OPEN) {
       return;
     }
     const socket = connection.socket;
@@ -90891,7 +91083,7 @@ var RuntimeSessionEventPublisher = class {
   flushEvents = (socket) => {
     this.cancelFlush();
     const connection = this.#connection;
-    if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket8.OPEN) {
+    if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket9.OPEN) {
       return;
     }
     let attempted = 0;
@@ -91204,7 +91396,8 @@ async function createMobiusRuntimeEngine(connection, signal, environment = proce
       (refreshSignal) => discover(refreshSignal),
       () => config2,
       publishAgentCatalog
-    )
+    ),
+    (refreshSignal) => discover(refreshSignal).then((inventory2) => inventory2.readyAgents())
   );
   return new MobiusRuntimeEngine(config2);
 }