machine-bridge-mcp 0.2.1 → 0.2.4

package/src/local/cli.mjs

@@ -4,7 +4,7 @@ import path, { resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalDaemon } from "./daemon.mjs";
-import { startLocalApiServer, DEFAULT_API_HOST, DEFAULT_API_PORT, DEFAULT_API_MODEL, DEFAULT_UPSTREAM_URL } from "./api-server.mjs";
+import { startLocalApiServer, DEFAULT_API_HOST, DEFAULT_API_PORT, DEFAULT_API_MODEL } from "./api-server.mjs";
 import { createLogger, redactSecret } from "./log.mjs";
 import { runWrangler } from "./shell.mjs";
 import {
@@ -257,6 +257,7 @@ async function apiCommand(args) {
   keepProcessAlive({ apiServer, logger });
 }
 
+
 async function startConfiguredApiServer(state, args, logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "api" })) {
   const apiOptions = apiOptionsFromArgs(state, args);
   return startLocalApiServer({ ...apiOptions, logger });
@@ -278,7 +279,7 @@ async function startOptionalApiServer(state, args, parentLogger) {
       parentLogger.warn(error.message);
       return null;
     }
-    parentLogger.warn(`Local API provider skipped: ${error.message}`);
+    parentLogger.warn(`Local API skipped: ${error.message}`);
     return null;
   }
 }
@@ -304,28 +305,25 @@ async function probeLocalApiHealth(baseUrl, expectedApiKey = "") {
 }
 
 function apiOptionsFromArgs(state, args = {}) {
-  const upstreamKey = valueFromArgsEnv(args.apiUpstreamKey, "MBM_API_UPSTREAM_KEY", "OPENAI_API_KEY");
   const explicitPort = explicitArg(args.apiPort) ?? explicitArg(args.port);
   const envPort = valueFromArgsEnv(undefined, "MBM_API_PORT", "PORT");
   return {
     host: valueFromArgsEnv(args.apiHost, "MBM_API_HOST") || state.localApi?.host || DEFAULT_API_HOST,
     port: explicitPort ?? envPort ?? state.localApi?.port ?? DEFAULT_API_PORT,
     apiKey: valueFromArgsEnv(args.apiKey, "MBM_API_KEY") || state.localApi?.apiKey || ensureLocalApiKey(state, { rotateApiKey: Boolean(args.rotateApiKey) }),
-    upstreamUrl: valueFromArgsEnv(args.apiUpstreamUrl, "MBM_API_UPSTREAM_URL", "OPENAI_BASE_URL", "OPENAI_API_BASE") || state.localApi?.upstreamUrl || DEFAULT_UPSTREAM_URL,
-    upstreamKey: upstreamKey || "",
-    model: valueFromArgsEnv(args.apiModel, "MBM_API_MODEL", "OPENAI_MODEL") || state.localApi?.model || DEFAULT_API_MODEL,
+    model: valueFromArgsEnv(args.apiModel, "MBM_API_MODEL") || state.localApi?.model || DEFAULT_API_MODEL,
+    workerUrl: state.worker?.url || "",
+    daemonSecret: state.worker?.daemonSecret || "",
   };
 }
 
 function configureLocalApiState(state, args = {}) {
   state.localApi ||= {};
-  ensureLocalApiKey(state, { apiKey: valueFromArgsEnv(args.apiKey, "MBM_API_KEY"), rotateApiKey: Boolean(args.rotateApiKey) });
+  ensureLocalApiKey(state, { apiKey: explicitArg(args.apiKey), rotateApiKey: Boolean(args.rotateApiKey) });
   const port = explicitArg(args.apiPort) ?? explicitArg(args.port);
   if (port !== undefined && String(port) !== "0") state.localApi.port = String(port);
   const host = explicitArg(args.apiHost);
   if (host !== undefined) state.localApi.host = String(host);
-  const upstreamUrl = explicitArg(args.apiUpstreamUrl);
-  if (upstreamUrl !== undefined) state.localApi.upstreamUrl = String(upstreamUrl);
   const model = explicitArg(args.apiModel);
   if (model !== undefined) state.localApi.model = String(model);
   state.localApi.updatedAt = new Date().toISOString();
@@ -506,7 +504,8 @@ async function waitForConnectWithNotice(promise, timeoutMs, quiet = false) {
 
 function printStartJson(state, apiServer, { noPrintCredentials = false } = {}) {
   const mcpPassword = noPrintCredentials ? previewSecret(state.worker.oauthPassword) : state.worker.oauthPassword;
-  const apiKey = state.localApi?.apiKey ? (noPrintCredentials ? previewSecret(state.localApi.apiKey) : state.localApi.apiKey) : null;
+  const runtimeApiKey = apiServer?.apiKey || state.localApi?.apiKey || "";
+  const apiKey = runtimeApiKey ? (noPrintCredentials ? previewSecret(runtimeApiKey) : runtimeApiKey) : null;
   createLogger({ component: "ready" }).json({
     mcp: {
       server_url: state.worker.mcpServerUrl,
@@ -518,6 +517,9 @@ function printStartJson(state, apiServer, { noPrintCredentials = false } = {}) {
       base_url: apiServer.baseUrl,
       api_key: apiKey,
       already_running: Boolean(apiServer.alreadyRunning),
+      backend: "chatgpt-mcp",
+      model: state.localApi?.model || DEFAULT_API_MODEL,
+      mcp_bridge_configured: Boolean(state.worker?.url && state.worker?.daemonSecret),
       client_type: "OpenAI-compatible",
     } : null,
     workspace: state.workspace.path,
@@ -527,10 +529,14 @@ function printStartJson(state, apiServer, { noPrintCredentials = false } = {}) {
 }
 
 function printApiJson(apiServer, state, { noPrintCredentials = false } = {}) {
+  const runtimeApiKey = apiServer?.apiKey || state.localApi?.apiKey || "";
   createLogger({ component: "ready" }).json({
     local_api: {
       base_url: apiServer.baseUrl,
-      api_key: noPrintCredentials ? previewSecret(state.localApi.apiKey) : state.localApi.apiKey,
+      api_key: noPrintCredentials ? previewSecret(runtimeApiKey) : runtimeApiKey,
+      backend: "chatgpt-mcp",
+      model: apiServer?.model || state.localApi?.model || DEFAULT_API_MODEL,
+      mcp_bridge_configured: Boolean(state.worker?.url && state.worker?.daemonSecret),
       client_type: "OpenAI-compatible",
     },
     workspace: state.workspace.path,
@@ -570,12 +576,18 @@ function printMcpConnection(state, { json = false, noPrintCredentials = false, i
 
 function printApiConnection(apiServer, state, { noPrintCredentials = false, quiet = false } = {}) {
   const logger = createLogger({ component: "ready", quiet });
-  logger.success("Local model API provider is ready");
+  const runtimeApiKey = apiServer?.apiKey || state.localApi?.apiKey || "";
+  logger.success("Local ChatGPT MCP-backed OpenAI-compatible API is running");
   logger.plain(`  API Base URL: ${apiServer.baseUrl}`);
-  logger.plain(`  API key: ${noPrintCredentials ? `${redactSecret(state.localApi.apiKey)} (redacted)` : state.localApi.apiKey}`);
+  logger.plain(`  API key: ${noPrintCredentials ? `${redactSecret(runtimeApiKey)} (redacted)` : runtimeApiKey}`);
   logger.plain("  Client type: OpenAI-compatible");
+  logger.plain(`  Model: ${apiServer?.model || state.localApi?.model || DEFAULT_API_MODEL}`);
+  logger.plain("  Backend: ChatGPT MCP sampling via the connected ChatGPT app");
+  if (state.worker?.mcpServerUrl) logger.plain(`  MCP Server URL: ${state.worker.mcpServerUrl}`);
+  else logger.plain("  MCP bridge: not deployed yet; run `machine-mcp` before using generation routes.");
 }
 
+
 function keepProcessAlive({ daemon = null, lock = null, apiServer = null, logger = createLogger({ component: "cli" }) } = {}) {
   let stopping = false;
   const stop = async () => {
@@ -778,7 +790,7 @@ Usage:
 
 Commands:
   start             Deploy/update Worker, install autostart, start daemon and local API
-  api               Start local OpenAI-compatible API provider only
+  api               Start local ChatGPT MCP-backed OpenAI-compatible API only
   workspace show    Show remembered workspace
   workspace set     Re-select workspace; prompts with current/default path
   service status    Show autostart status
@@ -805,16 +817,14 @@ Start options:
   --full-env            Pass full parent environment to exec_command (default: minimal env)
   --state-dir DIR       Override state root
   --json                Print MCP and local API connection details as JSON
-  --no-api              Do not start the local OpenAI-compatible API provider
+  --no-api              Do not start the local OpenAI-compatible API
   --api                 Deprecated no-op; local API starts by default
   --api-port PORT       Local API port (default: 8765)
   --port PORT           Alias for --api-port on the api command
   --api-host HOST       Local API host (default: 127.0.0.1)
   --api-key KEY         Set or replace local API key in state
   --rotate-api-key      Rotate local API key
-  --api-upstream-url URL  Upstream OpenAI-compatible base URL (default: https://api.openai.com/v1)
-  --api-upstream-key KEY  Upstream provider key; env OPENAI_API_KEY also works
-  --api-model MODEL     Model id advertised by /v1/models
+  --api-model MODEL     Local model id advertised by /v1/models (default: chatgpt-mcp)
 
 Uninstall options:
   --keep-worker         Do not delete deployed Worker(s) during uninstall
@@ -823,18 +833,19 @@ Uninstall options:
 }
 
 function apiUsage() {
-  console.log(`machine-bridge-mcp local API provider
+  console.log(`machine-bridge-mcp local ChatGPT MCP-backed API
 
 Usage:
   machine-mcp
   machine-mcp --api-port 8766
-  machine-mcp api                    # API provider only
+  machine-mcp api                    # local API only
   machine-mcp api --api-port 8766
 
 Client settings:
   API Base URL: http://127.0.0.1:<port>/v1
   API key: printed on startup unless --no-print-credentials is set
-  Client type: OpenAI-compatible
+  Model: chatgpt-mcp by default
+  Backend: connected ChatGPT app through the Remote MCP bridge
 
 Options:
   --workspace PATH        Use and remember this workspace path
@@ -843,19 +854,21 @@ Options:
   --port PORT             Alias for --api-port
   --api-key KEY           Set or replace local API key in state
   --rotate-api-key        Rotate local API key
-  --api-upstream-url URL  Upstream OpenAI-compatible base URL
-  --api-upstream-key KEY  Upstream provider key; env OPENAI_API_KEY also works
-  --api-model MODEL       Model id advertised by /v1/models
+  --api-model MODEL       Local model id advertised by /v1/models
   --no-print-credentials  Redact the local API key in console output
-  --no-api                Only valid for start; disables the default local API provider
+  --no-api                Only valid for start; disables the default local API
   --state-dir DIR         Override state root
 
+Important:
+  Generation routes require a ChatGPT app connected to the printed MCP Server URL.
+  The local API sends sampling/createMessage requests through that MCP connection.
+
 Environment:
-  MBM_API_HOST, MBM_API_PORT, MBM_API_KEY, MBM_API_UPSTREAM_URL, MBM_API_UPSTREAM_KEY, MBM_API_MODEL
-  OPENAI_API_KEY, OPENAI_BASE_URL, OPENAI_API_BASE, OPENAI_MODEL
+  MBM_API_HOST, MBM_API_PORT, MBM_API_KEY, MBM_API_MODEL
 `);
 }
 
+
 function version() {
   const pkg = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
   console.log(`${pkg.name} ${pkg.version}`);

package/src/local/self-test.mjs

@@ -1,11 +1,12 @@
 import { createHash } from "node:crypto";
+import http from "node:http";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { daemonSelfTest } from "./daemon.mjs";
-import { normalizeBaseUrl, startLocalApiServer } from "./api-server.mjs";
+import { startLocalApiServer } from "./api-server.mjs";
 import { createLogger, redactSecret } from "./log.mjs";
-import { acquireDaemonLock, ensureLocalApiKey, ensureWorkerSecrets, loadState, previewSecret, redactState, selectedWorkspace, setSelectedWorkspace } from "./state.mjs";
+import { acquireDaemonLock, ensureLocalApiKey, ensureWorkerSecrets, loadState, previewSecret, redactState, saveState, selectedWorkspace, setSelectedWorkspace } from "./state.mjs";
 
 await daemonSelfTest();
 await stateSelfTest();
@@ -41,6 +42,15 @@ async function stateSelfTest() {
     if (redacted.localApi.apiKey === state.localApi.apiKey) throw new Error("local API key was not redacted");
     if (!previewSecret(state.worker.oauthPassword).includes("...")) throw new Error("previewSecret did not preview long secret");
     if (!redactSecret(state.localApi.apiKey).includes("...")) throw new Error("redactSecret did not preview long secret");
+
+    state.localApi.upstreamUrl = "https://api.example.test/v1";
+    state.localApi.upstreamKey = "old-upstream-key";
+    state.localApi.upstreamModel = "old-upstream-model";
+    saveState(state);
+    const migrated = loadState(workspace, { stateDir: stateRoot });
+    if ("upstreamUrl" in migrated.localApi || "upstreamKey" in migrated.localApi || "upstreamModel" in migrated.localApi) {
+      throw new Error("legacy upstream local API state was not migrated away");
+    }
   } finally {
     await rm(stateRoot, { recursive: true, force: true }).catch(() => {});
     await rm(workspace, { recursive: true, force: true }).catch(() => {});
@@ -49,48 +59,182 @@ async function stateSelfTest() {
 
 
 async function apiSelfTest() {
-  try {
-    normalizeBaseUrl("https://user:pass@example.com/v1");
-    throw new Error("upstream URL credentials were accepted");
-  } catch (error) {
-    if (!/must not contain credentials/.test(error.message)) throw error;
-  }
-  try {
-    normalizeBaseUrl("https://example.com/v1?api_key=secret");
-    throw new Error("upstream URL query string was accepted");
-  } catch (error) {
-    if (!/without query strings/.test(error.message)) throw error;
-  }
-
   const logger = createLogger({ quiet: true, component: "api-test" });
   const api = await startLocalApiServer({
     host: "127.0.0.1",
     port: 0,
     apiKey: "local-test-key",
-    upstreamKey: "",
-    model: "test-model",
+    model: "chatgpt-mcp",
     logger,
   });
   const base = `http://${api.host}:${api.port}`;
   try {
+    if (api.apiKey !== "local-test-key") throw new Error("local API server did not expose runtime API key for CLI printing");
     const health = await fetch(`${base}/health`);
     if (health.status !== 200) throw new Error(`health returned ${health.status}`);
     const healthPayload = await health.json();
     const expectedHash = createHash("sha256").update("local-test-key").digest("hex");
     if (healthPayload.api_key_sha256 !== expectedHash) throw new Error("health did not expose expected API key hash");
+    if (healthPayload.backend !== "chatgpt-mcp") throw new Error("health did not report MCP-backed backend");
+    if (healthPayload.mcp_bridge_configured !== false) throw new Error("health should report missing MCP bridge");
     const unauth = await fetch(`${base}/v1/models`);
     if (unauth.status !== 401) throw new Error(`unauthorized models returned ${unauth.status}`);
     const models = await fetch(`${base}/v1/models`, { headers: { authorization: "Bearer local-test-key" } });
     if (models.status !== 200) throw new Error(`authorized models returned ${models.status}`);
     const payload = await models.json();
-    if (payload?.data?.[0]?.id !== "test-model") throw new Error("model payload did not include configured model");
+    if (payload?.data?.length !== 1 || payload.data[0].id !== "chatgpt-mcp") throw new Error("model payload should expose local MCP model");
     const chat = await fetch(`${base}/v1/chat/completions`, {
       method: "POST",
       headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
-      body: JSON.stringify({ model: "test-model", messages: [] }),
+      body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: "hello" }] }),
     });
-    if (chat.status !== 503) throw new Error(`missing upstream key should return 503, got ${chat.status}`);
+    if (chat.status !== 503) throw new Error(`missing MCP bridge should return 503, got ${chat.status}`);
+    const chatPayload = await chat.json();
+    if (!/Remote MCP bridge/.test(chatPayload?.error?.message || "")) throw new Error("missing bridge error did not clarify MCP bridge requirement");
+
+    const unsupported = await fetch(`${base}/v1/responses`, {
+      method: "POST",
+      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
+      body: JSON.stringify({ input: "hello" }),
+    });
+    if (unsupported.status !== 501) throw new Error(`unsupported Responses endpoint returned ${unsupported.status}`);
+    const unsupportedPayload = await unsupported.json();
+    if (unsupportedPayload?.error?.code !== "unsupported_endpoint") throw new Error("unsupported endpoint did not return explicit error code");
+
+  } finally {
+    await api.close();
+  }
+
+  await mcpSamplingSelfTest(logger);
+  await mcpSamplingErrorSelfTest(logger);
+}
+
+async function mcpSamplingSelfTest(logger) {
+  let captured = null;
+  const expectedErrorLogger = { ...logger, error() {} };
+  const worker = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", chunk => chunks.push(chunk));
+    req.on("end", () => {
+      captured = { bridgeToken: req.headers["x-bridge-token"], url: req.url, body: JSON.parse(Buffer.concat(chunks).toString("utf8")) };
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ ok: true, result: { role: "assistant", content: { type: "text", text: "hello from ChatGPT MCP" }, model: "chatgpt-client-model", stopReason: "endTurn" } }));
+    });
+  });
+  await new Promise(resolve => worker.listen({ host: "127.0.0.1", port: 0 }, resolve));
+  const workerPort = worker.address().port;
+  const api = await startLocalApiServer({
+    host: "127.0.0.1",
+    port: 0,
+    apiKey: "local-test-key",
+    workerUrl: `http://127.0.0.1:${workerPort}`,
+    daemonSecret: "daemon-test-secret",
+    model: "chatgpt-mcp",
+    logger: expectedErrorLogger,
+  });
+  try {
+    const models = await fetch(`http://${api.host}:${api.port}/v1/models`, { headers: { authorization: "Bearer local-test-key" } });
+    if (models.status !== 200) throw new Error(`configured models returned ${models.status}`);
+    const modelsPayload = await models.json();
+    if (modelsPayload?.data?.length !== 1 || modelsPayload.data[0].id !== "chatgpt-mcp") throw new Error("model payload did not expose local MCP model");
+
+    const image = await fetch(`http://${api.host}:${api.port}/v1/chat/completions`, {
+      method: "POST",
+      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
+      body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: [{ type: "image_url", image_url: { url: "https://example.test/image.png" } }] }] }),
+    });
+    if (image.status !== 400) throw new Error(`unsupported non-text content returned ${image.status}`);
+    const imagePayload = await image.json();
+    if (imagePayload?.error?.code !== "unsupported_content") throw new Error("unsupported non-text content did not return explicit error code");
+
+    const response = await fetch(`http://${api.host}:${api.port}/v1/chat/completions`, {
+      method: "POST",
+      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-5-hint",
+        messages: [
+          { role: "system", content: "Be concise." },
+          { role: "developer", content: "Use plain text." },
+          { role: "user", content: [{ type: "text", text: "Say hello" }] },
+        ],
+        max_completion_tokens: 77,
+      }),
+    });
+    if (response.status !== 200) throw new Error(`MCP sampling rewrite returned ${response.status}`);
+    if (captured?.url !== "/api/mcp/sampling") throw new Error("sampling request did not target Worker sampling endpoint");
+    if (captured?.bridgeToken !== "daemon-test-secret") throw new Error("bridge token was not set");
+    if (captured?.body?.messages?.[0]?.content?.text !== "Say hello") throw new Error("chat message was not converted to MCP sampling message");
+    if (captured?.body?.systemPrompt !== "Be concise.\n\nUse plain text.") throw new Error("system/developer prompt was not forwarded");
+    if (captured?.body?.maxTokens !== 77) throw new Error("max_completion_tokens was not converted to maxTokens");
+    if (captured?.body?.modelPreferences?.hints?.[0]?.name !== "gpt-5-hint") throw new Error("model hint was not forwarded");
+    const payload = await response.json();
+    if (payload?.choices?.[0]?.message?.content !== "hello from ChatGPT MCP") throw new Error("MCP sampling result was not wrapped as chat completion");
+    if (payload?.model !== "chatgpt-client-model") throw new Error("MCP sampling result model was not preserved");
+  } finally {
+    await api.close();
+    await new Promise(resolve => worker.close(resolve));
+  }
+}
+
+async function mcpSamplingErrorSelfTest(logger) {
+  await withMockWorkerError(
+    logger,
+    409,
+    { error: "mcp_client_stream_missing", message: "No MCP client has an open server-to-client stream for sampling/createMessage." },
+    async ({ base }) => {
+      const response = await fetch(`${base}/v1/chat/completions`, {
+        method: "POST",
+        headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
+        body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: "hello" }] }),
+      });
+      if (response.status !== 409) throw new Error(`missing MCP stream should return 409, got ${response.status}`);
+      const payload = await response.json();
+      if (payload?.error?.code !== "mcp_client_stream_missing") throw new Error("missing MCP stream error code was not preserved");
+      if (!/MCP client|server-to-client stream/.test(payload?.error?.message || "")) throw new Error("missing MCP stream error message was not explicit");
+    }
+  );
+
+  await withMockWorkerError(
+    logger,
+    501,
+    { error: "mcp_sampling_not_supported", message: "A connected MCP client did not advertise the MCP sampling capability." },
+    async ({ base }) => {
+      const response = await fetch(`${base}/v1/chat/completions`, {
+        method: "POST",
+        headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
+        body: JSON.stringify({ model: "chatgpt-mcp", messages: [{ role: "user", content: "hello" }] }),
+      });
+      if (response.status !== 501) throw new Error(`missing sampling capability should return 501, got ${response.status}`);
+      const payload = await response.json();
+      if (payload?.error?.code !== "mcp_sampling_not_supported") throw new Error("missing sampling capability error code was not preserved");
+      if (!/sampling capability/.test(payload?.error?.message || "")) throw new Error("missing sampling capability message was not explicit");
+    }
+  );
+}
+
+async function withMockWorkerError(logger, status, payload, callback) {
+  const expectedErrorLogger = { ...logger, error() {} };
+  const worker = http.createServer((req, res) => {
+    req.resume();
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify(payload));
+  });
+  await new Promise(resolve => worker.listen({ host: "127.0.0.1", port: 0 }, resolve));
+  const workerPort = worker.address().port;
+  const api = await startLocalApiServer({
+    host: "127.0.0.1",
+    port: 0,
+    apiKey: "local-test-key",
+    workerUrl: `http://127.0.0.1:${workerPort}`,
+    daemonSecret: "daemon-test-secret",
+    model: "chatgpt-mcp",
+    logger: expectedErrorLogger,
+  });
+  try {
+    await callback({ base: `http://${api.host}:${api.port}` });
   } finally {
     await api.close();
+    await new Promise(resolve => worker.close(resolve));
   }
 }

package/src/local/state.mjs

@@ -100,9 +100,17 @@ export function loadState(workspace, options = {}) {
   state.paths = { stateRoot, profileDir, statePath };
   state.worker ||= {};
   state.policy ||= {};
+  migrateLocalApiState(state);
   return state;
 }
 
+function migrateLocalApiState(state) {
+  if (!state.localApi || typeof state.localApi !== "object" || Array.isArray(state.localApi)) return;
+  delete state.localApi.upstreamUrl;
+  delete state.localApi.upstreamKey;
+  delete state.localApi.upstreamModel;
+}
+
 export function saveState(state) {
   const statePath = state?.paths?.statePath;
   if (!statePath) throw new Error("state path is missing");