@mobcode/openclaw-plugin 0.1.0

package/src/provider-catalog.js

@@ -0,0 +1,245 @@
+const STATIC_PROVIDER_CATALOG = [
+  {
+    id: "openai",
+    title: "OpenAI",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "anthropic",
+    title: "Anthropic",
+    defaultBaseUrl: "https://api.anthropic.com/v1",
+    defaultApi: "anthropic-messages",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "anthropic",
+  },
+  {
+    id: "google",
+    title: "Google (Gemini)",
+    defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "google",
+  },
+  {
+    id: "deepseek",
+    title: "DeepSeek",
+    defaultBaseUrl: "https://api.deepseek.com/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "openrouter",
+    title: "OpenRouter",
+    defaultBaseUrl: "https://openrouter.ai/api/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openrouter",
+  },
+  {
+    id: "xai",
+    title: "xAI (Grok)",
+    defaultBaseUrl: "https://api.x.ai/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "mistral",
+    title: "Mistral",
+    defaultBaseUrl: "https://api.mistral.ai/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "moonshot",
+    title: "Moonshot (Kimi)",
+    defaultBaseUrl: "https://api.moonshot.ai/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "kimi-coding",
+    title: "Kimi Coding",
+    defaultBaseUrl: "https://api.kimi.com/coding/",
+    defaultApi: "anthropic-messages",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "anthropic",
+  },
+  {
+    id: "qwen-portal",
+    title: "Qwen Portal",
+    defaultBaseUrl: "https://portal.qwen.ai/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "minimax",
+    title: "MiniMax",
+    defaultBaseUrl: "https://api.minimax.io/anthropic",
+    defaultApi: "anthropic-messages",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "anthropic",
+  },
+  {
+    id: "xiaomi",
+    title: "Xiaomi MiMo",
+    defaultBaseUrl: "https://api.xiaomimimo.com/anthropic",
+    defaultApi: "anthropic-messages",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "anthropic",
+  },
+  {
+    id: "venice",
+    title: "Venice",
+    defaultBaseUrl: "https://api.venice.ai/api/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "together",
+    title: "Together AI",
+    defaultBaseUrl: "https://api.together.xyz/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "huggingface",
+    title: "Hugging Face",
+    defaultBaseUrl: "https://router.huggingface.co/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "HF token",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "qianfan",
+    title: "Baidu Qianfan",
+    defaultBaseUrl: "https://qianfan.baidubce.com/v2",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "byteplus",
+    title: "BytePlus ModelArk",
+    defaultBaseUrl: "https://ark.ap-southeast.bytepluses.com/api/v3",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "byteplus-coding",
+    title: "BytePlus Coding",
+    defaultBaseUrl: "https://ark.ap-southeast.bytepluses.com/api/coding/v3",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "doubao",
+    title: "Doubao",
+    defaultBaseUrl: "https://ark.cn-beijing.volces.com/api/v3",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "doubao-coding",
+    title: "Doubao Coding",
+    defaultBaseUrl: "https://ark.cn-beijing.volces.com/api/coding/v3",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+  {
+    id: "nvidia",
+    title: "NVIDIA NIM",
+    defaultBaseUrl: "https://integrate.api.nvidia.com/v1",
+    defaultApi: "openai-completions",
+    defaultAuth: "api-key",
+    keyLabel: "API key",
+    modelFetchStrategy: "openai-compatible",
+  },
+];
+
+function cloneJson(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+export function listStaticProviders() {
+  return STATIC_PROVIDER_CATALOG.map((entry) => cloneJson(entry));
+}
+
+export function getStaticProvider(providerId) {
+  const normalized = String(providerId ?? "").trim().toLowerCase();
+  return (
+    STATIC_PROVIDER_CATALOG.find((entry) => entry.id.toLowerCase() === normalized) ?? null
+  );
+}
+
+export function buildStaticProvidersPayload() {
+  return {
+    generatedAt: new Date().toISOString(),
+    source: "mobcode-static-provider-catalog",
+    providers: STATIC_PROVIDER_CATALOG.map((entry) => ({
+      providerId: entry.id,
+      label: entry.title,
+      aliases: [],
+      envVars: [],
+      docsPath: null,
+      groupLabel: entry.title,
+      groupHint: null,
+      setupChoices: [
+        {
+          value: entry.id,
+          label: entry.title,
+          hint: null,
+          authKind: entry.defaultAuth,
+          methodId: entry.defaultAuth,
+          preset: {
+            baseUrl: entry.defaultBaseUrl,
+            api: entry.defaultApi,
+            auth: entry.defaultAuth,
+          },
+          defaultModel: null,
+          keyLabel: entry.keyLabel,
+        },
+      ],
+      modelPicker: [
+        {
+          choice: entry.id,
+          label: entry.title,
+          hint: null,
+        },
+      ],
+    })),
+  };
+}

package/src/provider-model-fetch.js

@@ -0,0 +1,265 @@
+import { getStaticProvider } from "./provider-catalog.js";
+
+function normalizeBase(baseUrl) {
+  const trimmed = String(baseUrl ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+
+function buildModelsUrl({ baseUrl, suffix, defaultPath, queryParameters }) {
+  const normalized = normalizeBase(baseUrl);
+  const uri = new URL(normalized);
+  const path = uri.pathname.trim() ? uri.pathname : defaultPath;
+  uri.pathname = path.endsWith("/") ? `${path.slice(0, -1)}${suffix}` : `${path}${suffix}`;
+  if (queryParameters) {
+    for (const [key, value] of Object.entries(queryParameters)) {
+      if (value !== undefined && value !== null && String(value).trim()) {
+        uri.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return uri;
+}
+
+async function fetchJson(url, init) {
+  const response = await fetch(url, init);
+  const body = await response.text();
+  if (!response.ok) {
+    const message = extractErrorMessage(body) ?? `HTTP ${response.status}`;
+    throw new Error(message);
+  }
+  if (!body.trim()) {
+    return {};
+  }
+  return JSON.parse(body);
+}
+
+function extractErrorMessage(body) {
+  const trimmed = String(body ?? "").trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const decoded = JSON.parse(trimmed);
+    if (decoded && typeof decoded === "object") {
+      if (decoded.error && typeof decoded.error === "object") {
+        const message = String(decoded.error.message ?? "").trim();
+        if (message) {
+          return message;
+        }
+      }
+      const message = String(decoded.message ?? "").trim();
+      if (message) {
+        return message;
+      }
+    }
+  } catch {}
+  return trimmed.length > 240 ? `${trimmed.slice(0, 237)}...` : trimmed;
+}
+
+function normalizeModelRows(providerId, ids) {
+  return [...new Set(ids.map((value) => String(value ?? "").trim()).filter(Boolean))]
+    .sort((a, b) => a.localeCompare(b))
+    .map((id) => ({
+      provider: providerId,
+      id,
+      name: id,
+    }));
+}
+
+async function fetchOpenAiCompatibleModels({ providerId, baseUrl, apiKey }) {
+  const url = buildModelsUrl({
+    baseUrl,
+    suffix: "/models",
+    defaultPath: "/v1",
+  });
+  const decoded = await fetchJson(url, {
+    headers: {
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+      "Content-Type": "application/json",
+    },
+  });
+  const data = Array.isArray(decoded?.data) ? decoded.data : [];
+  return normalizeModelRows(
+    providerId,
+    data.map((entry) => entry?.id ?? entry?.name),
+  );
+}
+
+async function fetchAnthropicModels({ providerId, baseUrl, apiKey }) {
+  if (!apiKey) {
+    throw new Error("API key is required for this provider");
+  }
+  const url = buildModelsUrl({
+    baseUrl,
+    suffix: "/models",
+    defaultPath: "/v1",
+  });
+  const decoded = await fetchJson(url, {
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "Content-Type": "application/json",
+    },
+  });
+  const data = Array.isArray(decoded?.data) ? decoded.data : [];
+  return normalizeModelRows(
+    providerId,
+    data.map((entry) => entry?.id ?? entry?.name),
+  );
+}
+
+async function fetchGoogleModels({ providerId, baseUrl, apiKey }) {
+  if (!apiKey) {
+    throw new Error("API key is required for this provider");
+  }
+  const normalizedBase = normalizeBase(baseUrl);
+  const baseWithoutCompat = normalizedBase.endsWith("/v1beta/openai")
+    ? normalizedBase.slice(0, -"/v1beta/openai".length)
+    : normalizedBase;
+  const url = buildModelsUrl({
+    baseUrl: baseWithoutCompat,
+    suffix: "/models",
+    defaultPath: "/v1beta",
+    queryParameters: { key: apiKey },
+  });
+  const decoded = await fetchJson(url, {
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+  const models = Array.isArray(decoded?.models) ? decoded.models : [];
+  return normalizeModelRows(
+    providerId,
+    models.map((entry) => {
+      const name = String(entry?.name ?? "").trim();
+      return name.startsWith("models/") ? name.slice(7) : name;
+    }),
+  );
+}
+
+async function fetchProviderModelsByStrategy({ providerId, strategy, baseUrl, apiKey }) {
+  switch (strategy) {
+    case "anthropic":
+      return await fetchAnthropicModels({ providerId, baseUrl, apiKey });
+    case "google":
+      return await fetchGoogleModels({ providerId, baseUrl, apiKey });
+    case "openrouter":
+    case "openai-compatible":
+    default:
+      return await fetchOpenAiCompatibleModels({ providerId, baseUrl, apiKey });
+  }
+}
+
+function resolveConfiguredProvider(config, providerId) {
+  const provider =
+    config?.models?.providers?.[providerId] &&
+    typeof config.models.providers[providerId] === "object" &&
+    !Array.isArray(config.models.providers[providerId])
+      ? config.models.providers[providerId]
+      : {};
+  return provider;
+}
+
+export async function buildProviderModelsPayloadFromInternet(api, providerId) {
+  const normalizedProviderId = String(providerId ?? "").trim().toLowerCase();
+  if (!normalizedProviderId) {
+    return {
+      generatedAt: new Date().toISOString(),
+      source: "mobcode-provider-api",
+      providerId: "",
+      models: [],
+      warning: "providerId required",
+    };
+  }
+
+  const staticProvider = getStaticProvider(normalizedProviderId);
+  if (!staticProvider) {
+    return {
+      generatedAt: new Date().toISOString(),
+      source: "mobcode-provider-api",
+      providerId: normalizedProviderId,
+      models: [],
+      warning: `Provider '${normalizedProviderId}' is not in the MobCode provider catalog.`,
+    };
+  }
+
+  const config = api.runtime.config.loadConfig();
+  const configuredProvider = resolveConfiguredProvider(config, normalizedProviderId);
+  const baseUrl =
+    String(configuredProvider.baseUrl ?? "").trim() || staticProvider.defaultBaseUrl;
+  const apiVersion = String(configuredProvider.api ?? "").trim() || staticProvider.defaultApi;
+  const authMode = String(configuredProvider.auth ?? "").trim() || staticProvider.defaultAuth;
+
+  let resolvedAuth = null;
+  try {
+    resolvedAuth = await api.runtime.modelAuth.resolveApiKeyForProvider({
+      provider: normalizedProviderId,
+      cfg: config,
+    });
+  } catch (error) {
+    return {
+      generatedAt: new Date().toISOString(),
+      source: "mobcode-provider-api",
+      providerId: normalizedProviderId,
+      models: [],
+      warning: `Could not resolve provider auth: ${error instanceof Error ? error.message : String(error)}`,
+      provider: {
+        baseUrl,
+        api: apiVersion,
+        auth: authMode,
+      },
+    };
+  }
+
+  const apiKey = String(resolvedAuth?.apiKey ?? "").trim();
+  if (!apiKey) {
+    return {
+      generatedAt: new Date().toISOString(),
+      source: "mobcode-provider-api",
+      providerId: normalizedProviderId,
+      models: [],
+      warning: `Provider '${normalizedProviderId}' is not authenticated yet.`,
+      provider: {
+        baseUrl,
+        api: apiVersion,
+        auth: authMode,
+      },
+    };
+  }
+
+  try {
+    const models = await fetchProviderModelsByStrategy({
+      providerId: normalizedProviderId,
+      strategy: staticProvider.modelFetchStrategy,
+      baseUrl,
+      apiKey,
+    });
+    return {
+      generatedAt: new Date().toISOString(),
+      source: "mobcode-provider-api",
+      providerId: normalizedProviderId,
+      provider: {
+        baseUrl,
+        api: apiVersion,
+        auth: authMode,
+      },
+      models,
+    };
+  } catch (error) {
+    return {
+      generatedAt: new Date().toISOString(),
+      source: "mobcode-provider-api",
+      providerId: normalizedProviderId,
+      provider: {
+        baseUrl,
+        api: apiVersion,
+        auth: authMode,
+      },
+      models: [],
+      warning: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/runtime-events.js

@@ -0,0 +1,96 @@
+import { tryCreateOperatorApprovalsGatewayClient } from "./openclaw-gateway-runtime.js";
+
+function createPushPayloadFromTranscript(update) {
+  return {
+    type: "session.transcript.update",
+    sessionKey: update.sessionKey ?? null,
+    messageId: update.messageId ?? null,
+    sessionFile: update.sessionFile,
+  };
+}
+
+function createPushPayloadFromAgentEvent(event) {
+  return {
+    type: "agent.event",
+    runId: event.runId,
+    stream: event.stream,
+    sessionKey: event.sessionKey ?? null,
+    data: event.data ?? {},
+  };
+}
+
+function createPushPayloadFromApprovalEvent(event, payload) {
+  return {
+    type: event,
+    sessionKey: payload?.request?.sessionKey ?? null,
+    approvalId: payload?.id ?? null,
+    payload,
+  };
+}
+
+export function registerMobcodeRuntimeObservers({ api, store, pluginConfig }) {
+  const retainMessages = pluginConfig?.storage?.retainMessages !== false;
+  const pushEnabled = pluginConfig?.push?.enabled === true;
+  let approvalsClient = null;
+
+  api.registerService({
+    id: "mobcode-runtime-observers",
+    async start(ctx) {
+      await store.init();
+
+      api.runtime.events.onSessionTranscriptUpdate(async (update) => {
+        if (retainMessages && update?.message !== undefined) {
+          await store.appendMessage(update);
+        }
+        if (pushEnabled) {
+          await store.enqueuePush(createPushPayloadFromTranscript(update));
+        }
+      });
+
+      api.runtime.events.onAgentEvent(async (event) => {
+        if (!pushEnabled) {
+          return;
+        }
+        const stream = typeof event?.stream === "string" ? event.stream : "";
+        if (stream !== "lifecycle" && stream !== "assistant" && stream !== "tool") {
+          return;
+        }
+        await store.enqueuePush(createPushPayloadFromAgentEvent(event));
+      });
+
+      approvalsClient = await tryCreateOperatorApprovalsGatewayClient({
+        config: ctx.config,
+        clientDisplayName: "MobCode Exec Approvals",
+        onEvent: async (eventFrame) => {
+          if (eventFrame?.event === "exec.approval.requested") {
+            await store.recordApprovalRequested(eventFrame.payload);
+            if (pushEnabled) {
+              await store.enqueuePush(
+                createPushPayloadFromApprovalEvent(eventFrame.event, eventFrame.payload),
+              );
+            }
+            return;
+          }
+          if (eventFrame?.event === "exec.approval.resolved") {
+            await store.recordApprovalResolved(eventFrame.payload);
+            if (pushEnabled) {
+              await store.enqueuePush(
+                createPushPayloadFromApprovalEvent(eventFrame.event, eventFrame.payload),
+              );
+            }
+          }
+        },
+        onConnectError: (err) => {
+          api.logger.warn(`mobcode approvals listener connect error: ${err.message}`);
+        },
+      });
+      approvalsClient?.start();
+
+      api.logger.info("mobcode runtime observers started");
+    },
+    async stop() {
+      approvalsClient?.stop();
+      approvalsClient = null;
+    },
+  });
+}