nextclaw 0.13.40 → 0.14.0

package/dist/cli/index.js

@@ -5475,7 +5475,8 @@ var resolveCliSubcommandEntry = (params) => {
 
 // src/cli/commands/ncp/create-ui-ncp-agent.ts
 import {
-  DisposableStore
+  DisposableStore,
+  resolveProviderRuntime
 } from "@nextclaw/core";
 import { McpRegistryService as McpRegistryService2, McpServerLifecycleManager } from "@nextclaw/mcp";
 import { DefaultNcpAgentRuntime } from "@nextclaw/ncp-agent-runtime";
@@ -5485,7 +5486,10 @@ import {
   readAssistantReasoningNormalizationModeFromMetadata,
   writeAssistantReasoningNormalizationModeToMetadata
 } from "@nextclaw/ncp";
-import { createAgentClientFromServer, DefaultNcpAgentBackend } from "@nextclaw/ncp-toolkit";
+import {
+  createAgentClientFromServer,
+  DefaultNcpAgentBackend
+} from "@nextclaw/ncp-toolkit";
 
 // src/cli/commands/ncp/nextclaw-ncp-context-builder.ts
 import {
@@ -6657,9 +6661,58 @@ var UiNcpRuntimeRegistry = class {
 };
 
 // src/cli/commands/ncp/create-ui-ncp-agent.ts
+var CODEX_RUNTIME_KIND = "codex";
+var CODEX_DIRECT_RUNTIME_BACKEND = "codex-sdk";
+var CODEX_NATIVE_RUNTIME_BACKEND = "native-openai-compatible";
 function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function readOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function resolveCodexRequestedModel(params) {
+  return readOptionalString(params.sessionMetadata.preferred_model) ?? readOptionalString(params.sessionMetadata.model) ?? params.config.agents.defaults.model;
+}
+function isCodexDirectModelFamily(model) {
+  const normalized = model.trim().toLowerCase();
+  return normalized.startsWith("gpt-") || normalized.startsWith("chatgpt-") || normalized.startsWith("codex-") || normalized.startsWith("o1") || normalized.startsWith("o3") || normalized.startsWith("o4");
+}
+function shouldRouteCodexSessionToNativeRuntime(params) {
+  const requestedModel = resolveCodexRequestedModel(params);
+  try {
+    const resolvedProviderRuntime = resolveProviderRuntime(params.config, requestedModel);
+    if (resolvedProviderRuntime.providerName === "openai") {
+      return false;
+    }
+    return !isCodexDirectModelFamily(resolvedProviderRuntime.providerLocalModel);
+  } catch {
+    return false;
+  }
+}
+function decorateCodexRuntimeFactoryParams(runtimeParams, backend) {
+  const nextSessionMetadata = {
+    ...runtimeParams.sessionMetadata,
+    session_type: CODEX_RUNTIME_KIND,
+    codex_runtime_backend: backend
+  };
+  const setSessionMetadata = (nextMetadata) => {
+    runtimeParams.setSessionMetadata({
+      ...nextMetadata,
+      session_type: CODEX_RUNTIME_KIND,
+      codex_runtime_backend: backend
+    });
+  };
+  setSessionMetadata(nextSessionMetadata);
+  return {
+    ...runtimeParams,
+    sessionMetadata: nextSessionMetadata,
+    setSessionMetadata
+  };
+}
 function resolveNativeReasoningNormalizationMode(params) {
   const runtimeEntry = params.config.ui.ncp.runtimes.native;
   const runtimeMetadata = isRecord5(runtimeEntry) ? runtimeEntry : {};
@@ -6674,10 +6727,8 @@ function buildPluginRuntimeSnapshotKey(extensionRegistry) {
     registration.source
   ].join(":")).join("|");
 }
-async function createUiNcpAgent(params) {
-  const sessionStore = new NextclawAgentSessionStore(params.sessionManager);
-  const runtimeRegistry = new UiNcpRuntimeRegistry();
-  let currentMcpConfig = params.getConfig();
+async function createMcpRuntimeSupport(getConfig) {
+  let currentMcpConfig = getConfig();
   const mcpLifecycleManager = new McpServerLifecycleManager({
     getConfig: () => currentMcpConfig
   });
@@ -6691,49 +6742,84 @@ async function createUiNcpAgent(params) {
       console.warn(`[mcp] Failed to warm ${result.name}: ${result.error}`);
     }
   }
-  const mcpToolRegistryAdapter = new McpNcpToolRegistryAdapter(mcpRegistryService);
-  runtimeRegistry.register({
-    kind: "native",
-    label: "Native",
-    createRuntime: ({ stateManager, sessionMetadata, setSessionMetadata }) => {
-      const reasoningNormalizationMode = resolveNativeReasoningNormalizationMode({
-        config: params.getConfig(),
-        sessionMetadata
+  return {
+    toolRegistryAdapter: new McpNcpToolRegistryAdapter(mcpRegistryService),
+    applyMcpConfig: async (config2) => {
+      const previousConfig = currentMcpConfig;
+      currentMcpConfig = config2;
+      const reconcileResult = await mcpRegistryService.reconcileConfig({
+        prevConfig: previousConfig,
+        nextConfig: config2
       });
-      if (reasoningNormalizationMode !== "off" && readAssistantReasoningNormalizationModeFromMetadata(sessionMetadata) !== reasoningNormalizationMode) {
-        setSessionMetadata(
-          writeAssistantReasoningNormalizationModeToMetadata(
-            sessionMetadata,
-            reasoningNormalizationMode
-          )
-        );
+      for (const warmResult of reconcileResult.warmed) {
+        if (!warmResult.ok) {
+          console.warn(`[mcp] Failed to warm ${warmResult.name}: ${warmResult.error}`);
+        }
       }
-      const toolRegistry = new NextclawNcpToolRegistry({
-        bus: params.bus,
-        providerManager: params.providerManager,
+    }
+  };
+}
+function createNativeRuntimeFactory(params, mcpToolRegistryAdapter) {
+  return ({
+    stateManager,
+    sessionMetadata,
+    setSessionMetadata
+  }) => {
+    const reasoningNormalizationMode = resolveNativeReasoningNormalizationMode({
+      config: params.getConfig(),
+      sessionMetadata
+    });
+    if (reasoningNormalizationMode !== "off" && readAssistantReasoningNormalizationModeFromMetadata(sessionMetadata) !== reasoningNormalizationMode) {
+      setSessionMetadata(
+        writeAssistantReasoningNormalizationModeToMetadata(
+          sessionMetadata,
+          reasoningNormalizationMode
+        )
+      );
+    }
+    const toolRegistry = new NextclawNcpToolRegistry({
+      bus: params.bus,
+      providerManager: params.providerManager,
+      sessionManager: params.sessionManager,
+      cronService: params.cronService,
+      gatewayController: params.gatewayController,
+      getConfig: params.getConfig,
+      getExtensionRegistry: params.getExtensionRegistry,
+      getAdditionalTools: (context) => mcpToolRegistryAdapter.listToolsForRun({
+        agentId: context.agentId
+      })
+    });
+    return new DefaultNcpAgentRuntime({
+      contextBuilder: new NextclawNcpContextBuilder({
         sessionManager: params.sessionManager,
-        cronService: params.cronService,
-        gatewayController: params.gatewayController,
-        getConfig: params.getConfig,
-        getExtensionRegistry: params.getExtensionRegistry,
-        getAdditionalTools: (context) => mcpToolRegistryAdapter.listToolsForRun({
-          agentId: context.agentId
-        })
-      });
-      return new DefaultNcpAgentRuntime({
-        contextBuilder: new NextclawNcpContextBuilder({
-          sessionManager: params.sessionManager,
-          toolRegistry,
-          getConfig: params.getConfig,
-          resolveMessageToolHints: params.resolveMessageToolHints
-        }),
-        llmApi: new ProviderManagerNcpLLMApi(params.providerManager),
         toolRegistry,
-        stateManager,
-        reasoningNormalizationMode
-      });
-    }
-  });
+        getConfig: params.getConfig,
+        resolveMessageToolHints: params.resolveMessageToolHints
+      }),
+      llmApi: new ProviderManagerNcpLLMApi(params.providerManager),
+      toolRegistry,
+      stateManager,
+      reasoningNormalizationMode
+    });
+  };
+}
+function createCodexAwareRuntimeFactory(params) {
+  return (runtimeParams) => {
+    const backend = shouldRouteCodexSessionToNativeRuntime({
+      config: params.getConfig(),
+      sessionMetadata: runtimeParams.sessionMetadata
+    }) ? CODEX_NATIVE_RUNTIME_BACKEND : CODEX_DIRECT_RUNTIME_BACKEND;
+    const decoratedRuntimeParams = decorateCodexRuntimeFactoryParams(
+      runtimeParams,
+      backend
+    );
+    return backend === CODEX_NATIVE_RUNTIME_BACKEND ? params.createNativeRuntime(decoratedRuntimeParams) : params.registration.createRuntime(decoratedRuntimeParams);
+  };
+}
+function resolveRegisteredRuntimeFactory(params) {
+  return params.registration.kind === CODEX_RUNTIME_KIND ? createCodexAwareRuntimeFactory(params) : params.registration.createRuntime;
+}
+function createPluginRuntimeRegistrationController(params) {
   const pluginRuntimeScopes = /* @__PURE__ */ new Map();
   let pluginRuntimeSnapshotKey = "";
   let activeExtensionRegistry;
@@ -6749,60 +6835,78 @@ async function createUiNcpAgent(params) {
     pluginRuntimeScopes.clear();
     for (const registration of extensionRegistry?.ncpAgentRuntimes ?? []) {
       const pluginId = registration.pluginId.trim() || registration.kind;
-      let scope = pluginRuntimeScopes.get(pluginId);
-      if (!scope) {
-        scope = new DisposableStore();
-        pluginRuntimeScopes.set(pluginId, scope);
-      }
-      scope.add(runtimeRegistry.register({
+      const scope = pluginRuntimeScopes.get(pluginId) ?? new DisposableStore();
+      pluginRuntimeScopes.set(pluginId, scope);
+      scope.add(params.runtimeRegistry.register({
         kind: registration.kind,
         label: registration.label,
-        createRuntime: registration.createRuntime,
+        createRuntime: resolveRegisteredRuntimeFactory({
+          getConfig: params.getConfig,
+          createNativeRuntime: params.createNativeRuntime,
+          registration
+        }),
         describeSessionType: registration.describeSessionType
       }));
     }
   };
   const resolveActiveExtensionRegistry = () => activeExtensionRegistry ?? params.getExtensionRegistry?.();
-  const refreshPluginRuntimeRegistrations = () => {
-    syncPluginRuntimeRegistrations(resolveActiveExtensionRegistry());
+  return {
+    refreshPluginRuntimeRegistrations: () => {
+      syncPluginRuntimeRegistrations(resolveActiveExtensionRegistry());
+    },
+    applyExtensionRegistry: (extensionRegistry) => {
+      activeExtensionRegistry = extensionRegistry;
+      syncPluginRuntimeRegistrations(extensionRegistry);
+    }
+  };
+}
+function createUiNcpAgentHandle(params) {
+  return {
+    basePath: "/api/ncp/agent",
+    agentClientEndpoint: createAgentClientFromServer(params.backend),
+    streamProvider: params.backend,
+    sessionApi: params.backend,
+    listSessionTypes: () => {
+      params.refreshPluginRuntimeRegistrations();
+      return params.runtimeRegistry.listSessionTypes();
+    },
+    applyExtensionRegistry: params.applyExtensionRegistry,
+    applyMcpConfig: params.applyMcpConfig
   };
-  refreshPluginRuntimeRegistrations();
+}
+async function createUiNcpAgent(params) {
+  const sessionStore = new NextclawAgentSessionStore(params.sessionManager);
+  const runtimeRegistry = new UiNcpRuntimeRegistry();
+  const { toolRegistryAdapter, applyMcpConfig } = await createMcpRuntimeSupport(params.getConfig);
+  const createNativeRuntime = createNativeRuntimeFactory(params, toolRegistryAdapter);
+  runtimeRegistry.register({
+    kind: "native",
+    label: "Native",
+    createRuntime: createNativeRuntime
+  });
+  const pluginRuntimeRegistrationController = createPluginRuntimeRegistrationController({
+    runtimeRegistry,
+    getConfig: params.getConfig,
+    getExtensionRegistry: params.getExtensionRegistry,
+    createNativeRuntime
+  });
+  pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
   const backend = new DefaultNcpAgentBackend({
     endpointId: "nextclaw-ui-agent",
     sessionStore,
     createRuntime: (runtimeParams) => {
-      refreshPluginRuntimeRegistrations();
+      pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations();
       return runtimeRegistry.createRuntime(runtimeParams);
     }
   });
   await backend.start();
-  return {
-    basePath: "/api/ncp/agent",
-    agentClientEndpoint: createAgentClientFromServer(backend),
-    streamProvider: backend,
-    sessionApi: backend,
-    listSessionTypes: () => {
-      refreshPluginRuntimeRegistrations();
-      return runtimeRegistry.listSessionTypes();
-    },
-    applyExtensionRegistry: (extensionRegistry) => {
-      activeExtensionRegistry = extensionRegistry;
-      syncPluginRuntimeRegistrations(extensionRegistry);
-    },
-    applyMcpConfig: async (config2) => {
-      const previousConfig = currentMcpConfig;
-      currentMcpConfig = config2;
-      const reconcileResult = await mcpRegistryService.reconcileConfig({
-        prevConfig: previousConfig,
-        nextConfig: config2
-      });
-      for (const warmResult of reconcileResult.warmed) {
-        if (!warmResult.ok) {
-          console.warn(`[mcp] Failed to warm ${warmResult.name}: ${warmResult.error}`);
-        }
-      }
-    }
-  };
+  return createUiNcpAgentHandle({
+    backend,
+    runtimeRegistry,
+    refreshPluginRuntimeRegistrations: pluginRuntimeRegistrationController.refreshPluginRuntimeRegistrations,
+    applyExtensionRegistry: pluginRuntimeRegistrationController.applyExtensionRegistry,
+    applyMcpConfig
+  });
 }
 
 // src/cli/commands/service-remote-runtime.ts
@@ -7214,7 +7318,7 @@ function createRunId() {
 function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function readOptionalString(value) {
+function readOptionalString2(value) {
   if (typeof value !== "string") {
     return void 0;
   }
@@ -7304,7 +7408,7 @@ var UiChatRunCoordinator = class {
     return run ? this.toRunView(run) : null;
   }
   listRuns(params = {}) {
-    const sessionKey = readOptionalString(params.sessionKey);
+    const sessionKey = readOptionalString2(params.sessionKey);
     const stateFilter = Array.isArray(params.states) && params.states.length > 0 ? new Set(params.states) : null;
     const limit = Number.isFinite(params.limit) ? Math.max(0, Math.trunc(params.limit)) : 0;
     const records = Array.from(this.runs.values()).filter((run) => {
@@ -7341,7 +7445,7 @@ var UiChatRunCoordinator = class {
     }
   }
   async stopRun(params) {
-    const runId = readOptionalString(params.runId) ?? "";
+    const runId = readOptionalString2(params.runId) ?? "";
     if (!runId) {
       return {
         stopped: false,
@@ -7354,11 +7458,11 @@ var UiChatRunCoordinator = class {
       return {
         stopped: false,
         runId,
-        ...readOptionalString(params.sessionKey) ? { sessionKey: readOptionalString(params.sessionKey) } : {},
+        ...readOptionalString2(params.sessionKey) ? { sessionKey: readOptionalString2(params.sessionKey) } : {},
         reason: "run not found or already completed"
       };
     }
-    const requestedSessionKey = readOptionalString(params.sessionKey);
+    const requestedSessionKey = readOptionalString2(params.sessionKey);
     if (requestedSessionKey && requestedSessionKey !== run.sessionKey) {
       return {
         stopped: false,
@@ -7395,17 +7499,17 @@ var UiChatRunCoordinator = class {
     };
   }
   resolveRequest(input) {
-    const message = readOptionalString(input.message) ?? "";
-    const sessionKey = readOptionalString(input.sessionKey) ?? `ui:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
-    const explicitAgentId = readOptionalString(input.agentId);
+    const message = readOptionalString2(input.message) ?? "";
+    const sessionKey = readOptionalString2(input.sessionKey) ?? `ui:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
+    const explicitAgentId = readOptionalString2(input.agentId);
     const parsedAgentId = parseAgentScopedSessionKey3(sessionKey)?.agentId;
-    const agentId = explicitAgentId ?? readOptionalString(parsedAgentId);
-    const model = readOptionalString(input.model);
+    const agentId = explicitAgentId ?? readOptionalString2(parsedAgentId);
+    const model = readOptionalString2(input.model);
     const metadata = isRecord6(input.metadata) ? { ...input.metadata } : {};
     if (model) {
       metadata.model = model;
     }
-    const runId = readOptionalString(input.runId) ?? createRunId();
+    const runId = readOptionalString2(input.runId) ?? createRunId();
     return {
       runId,
       message,
@@ -7413,16 +7517,16 @@ var UiChatRunCoordinator = class {
       ...agentId ? { agentId } : {},
       ...model ? { model } : {},
       metadata,
-      channel: readOptionalString(input.channel) ?? "ui",
-      chatId: readOptionalString(input.chatId) ?? "web-ui"
+      channel: readOptionalString2(input.channel) ?? "ui",
+      chatId: readOptionalString2(input.chatId) ?? "web-ui"
     };
   }
   readRequestedSessionType(metadata) {
-    const value = readOptionalString(metadata.session_type) ?? readOptionalString(metadata.sessionType);
+    const value = readOptionalString2(metadata.session_type) ?? readOptionalString2(metadata.sessionType);
     return value ? value.toLowerCase() : void 0;
   }
   readStoredSessionType(metadata) {
-    const value = readOptionalString(metadata[SESSION_TYPE_METADATA_KEY]);
+    const value = readOptionalString2(metadata[SESSION_TYPE_METADATA_KEY]);
     return value ? value.toLowerCase() : DEFAULT_SESSION_TYPE;
   }
   countUserMessages(session) {
@@ -7545,7 +7649,7 @@ var UiChatRunCoordinator = class {
         });
         run.reply = partialReply;
         this.transitionState(run, "aborted", {
-          error: abortController?.signal.reason instanceof Error ? abortController.signal.reason.message : readOptionalString(abortController?.signal.reason)
+          error: abortController?.signal.reason instanceof Error ? abortController.signal.reason.message : readOptionalString2(abortController?.signal.reason)
         });
         return;
       }
@@ -7760,8 +7864,8 @@ var UiChatRunCoordinator = class {
       const path2 = join5(RUNS_DIR, entry.name);
       try {
         const parsed = JSON.parse(readFileSync8(path2, "utf-8"));
-        const runId = readOptionalString(parsed.runId);
-        const sessionKey = readOptionalString(parsed.sessionKey);
+        const runId = readOptionalString2(parsed.runId);
+        const sessionKey = readOptionalString2(parsed.sessionKey);
         if (!runId || !sessionKey) {
           continue;
         }
@@ -7770,15 +7874,15 @@ var UiChatRunCoordinator = class {
         const run = {
           runId,
           sessionKey,
-          ...readOptionalString(parsed.agentId) ? { agentId: readOptionalString(parsed.agentId) } : {},
-          ...readOptionalString(parsed.model) ? { model: readOptionalString(parsed.model) } : {},
+          ...readOptionalString2(parsed.agentId) ? { agentId: readOptionalString2(parsed.agentId) } : {},
+          ...readOptionalString2(parsed.model) ? { model: readOptionalString2(parsed.model) } : {},
           state,
-          requestedAt: readOptionalString(parsed.requestedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
-          ...readOptionalString(parsed.startedAt) ? { startedAt: readOptionalString(parsed.startedAt) } : {},
-          ...readOptionalString(parsed.completedAt) ? { completedAt: readOptionalString(parsed.completedAt) } : {},
+          requestedAt: readOptionalString2(parsed.requestedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+          ...readOptionalString2(parsed.startedAt) ? { startedAt: readOptionalString2(parsed.startedAt) } : {},
+          ...readOptionalString2(parsed.completedAt) ? { completedAt: readOptionalString2(parsed.completedAt) } : {},
           stopSupported: Boolean(parsed.stopSupported),
-          ...readOptionalString(parsed.stopReason) ? { stopReason: readOptionalString(parsed.stopReason) } : {},
-          ...readOptionalString(parsed.error) ? { error: readOptionalString(parsed.error) } : {},
+          ...readOptionalString2(parsed.stopReason) ? { stopReason: readOptionalString2(parsed.stopReason) } : {},
+          ...readOptionalString2(parsed.error) ? { error: readOptionalString2(parsed.error) } : {},
           ...typeof parsed.reply === "string" ? { reply: parsed.reply } : {},
           events,
           waiters: /* @__PURE__ */ new Set(),
@@ -7804,7 +7908,7 @@ var UiChatRunCoordinator = class {
     return "failed";
   }
   getRunRecord(runId) {
-    const normalized = readOptionalString(runId);
+    const normalized = readOptionalString2(runId);
     if (!normalized) {
       return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextclaw",
-  "version": "0.13.40",
+  "version": "0.14.0",
   "description": "Lightweight personal AI assistant with CLI, multi-provider routing, and channel integrations.",
   "private": false,
   "type": "module",
@@ -39,16 +39,16 @@
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
     "yaml": "^2.8.1",
-    "@nextclaw/mcp": "0.1.32",
+    "@nextclaw/core": "0.10.0",
+    "@nextclaw/mcp": "0.1.33",
+    "@nextclaw/ncp": "0.3.2",
     "@nextclaw/ncp-agent-runtime": "0.2.2",
-    "@nextclaw/core": "0.9.12",
-    "@nextclaw/ncp-mcp": "0.1.31",
+    "@nextclaw/ncp-mcp": "0.1.32",
     "@nextclaw/ncp-toolkit": "0.4.2",
-    "@nextclaw/ncp": "0.3.2",
-    "@nextclaw/runtime": "0.2.12",
-    "@nextclaw/openclaw-compat": "0.3.18",
-    "@nextclaw/remote": "0.1.30",
-    "@nextclaw/server": "0.10.36"
+    "@nextclaw/runtime": "0.2.13",
+    "@nextclaw/server": "0.10.37",
+    "@nextclaw/openclaw-compat": "0.3.19",
+    "@nextclaw/remote": "0.1.31"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
@@ -57,7 +57,7 @@
     "tsx": "^4.19.2",
     "typescript": "^5.6.3",
     "vitest": "^2.1.2",
-    "@nextclaw/ui": "0.9.17"
+    "@nextclaw/ui": "0.10.0"
   },
   "scripts": {
     "dev": "tsx watch --tsconfig tsconfig.json src/cli/index.ts",