openclaw-openagent 1.0.12 → 1.0.14

package/src/channel.ts

@@ -1,566 +0,0 @@
-/**
- * OpenAgent Channel Adapter — OpenClaw channel plugin interface
- *
- * Assembles the v3 modular architecture:
- *   auth/ → runtime/ → tim/ → messaging/ → tools
- *
- * Gateway lifecycle uses AccountRuntime with transaction-style
- * start/stop and RuntimeRegistry enforcement.
- */
-
-import { DEFAULT_OASN_API_BASE, isUnconfiguredOasnApiBase, resolveOpenagentAccount, getOpenagentConfig } from './auth/config.js';
-import { registry } from './runtime/registry.js';
-import { AccountRuntime } from './runtime/account.js';
-
-import { logger } from './util/logger.js';
-import { resolveOasnRelativeUrl } from './util/url-resolver.js';
-import * as timMessages from './tim/messages.js';
-
-const API_BASE = 'https://api.clawlink.club';
-const OASN_TRANSPORT = 'oasn';
-
-// ── Channel adapter meta ──
-
-const meta = {
-  id: 'openagent',
-  label: 'OpenAgent',
-  selectionLabel: 'OpenAgent (Agent Network)',
-  detailLabel: 'OpenAgent Agent Network',
-  docsPath: '/channels/openagent',
-  docsLabel: 'openagent',
-  blurb: 'Connect to OASN agent social network via Tencent IM.',
-  aliases: ['openagent', 'agent-network'],
-  order: 90,
-  quickstartAllowFrom: true,
-};
-
-// ── Channel plugin object ──
-
-export const openagentPlugin = {
-  id: 'openagent',
-  meta,
-
-  capabilities: {
-    chatTypes: ['group'],
-    media: false,
-    reactions: true,
-    threads: false,
-    polls: false,
-    nativeCommands: false,
-  },
-
-  reload: { configPrefixes: ['channels.openagent'] },
-
-  config: {
-    listAccountIds: (cfgOrCtx: Record<string, unknown>) => {
-      const cfg = (cfgOrCtx as { cfg?: Record<string, unknown> })?.cfg
-        || (cfgOrCtx?.['channels'] ? cfgOrCtx : {});
-      const clCfg = getOpenagentConfig(cfg);
-      const keys = Object.keys((clCfg['accounts'] || {}) as Record<string, unknown>);
-      return keys.length > 0 ? keys : ['default'];
-    },
-    resolveAccount: (cfg: Record<string, unknown>, accountId: string) =>
-      resolveOpenagentAccount(cfg, accountId),
-    defaultAccountId: (cfgOrCtx: Record<string, unknown>) => {
-      const cfg = (cfgOrCtx as { cfg?: Record<string, unknown> })?.cfg
-        || (cfgOrCtx?.['channels'] ? cfgOrCtx : {});
-      const clCfg = getOpenagentConfig(cfg);
-      const keys = Object.keys((clCfg['accounts'] || {}) as Record<string, unknown>);
-      return keys.length > 0 ? keys[0] : 'default';
-    },
-    setAccountEnabled: ({ cfg, enabled }: { cfg: Record<string, unknown>; enabled: boolean }) => ({
-      ...cfg,
-      channels: {
-        ...(cfg['channels'] as Record<string, unknown>),
-        openagent: { ...((cfg['channels'] as Record<string, unknown>)?.['openagent'] as Record<string, unknown>), enabled },
-      },
-    }),
-    deleteAccount: ({ cfg }: { cfg: Record<string, unknown> }) => {
-      const channels = { ...(cfg['channels'] as Record<string, unknown>) };
-      delete channels['openagent'];
-      return { ...cfg, channels };
-    },
-    isConfigured: (account: { configured: boolean }) => account.configured,
-    describeAccount: (account: { accountId: string; name: string; enabled: boolean; configured: boolean; transport?: string; status?: string }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      tokenStatus: account.configured ? 'available' : 'missing',
-      transport: account.transport ?? 'oasn',
-      claimStatus: account.status ?? 'unknown',
-    }),
-  },
-
-  security: {
-    resolveDmPolicy: () => ({
-      policy: 'open',
-      allowFrom: ['*'],
-      policyPath: 'channels.openagent.dm.policy',
-      allowFromPath: 'channels.openagent.dm.allowFrom',
-      normalizeEntry: (raw: string) => raw.trim(),
-    }),
-  },
-
-  groups: {
-    resolveRequireMention: () => false,
-  },
-
-  threading: {
-    resolveReplyToMode: () => 'first',
-  },
-
-  messaging: {
-    normalizeTarget: (raw: string) => {
-      const trimmed = raw.trim();
-      if (!trimmed) return undefined;
-      return trimmed.replace(/^(openagent):/i, '').trim() || undefined;
-    },
-    targetResolver: {
-      looksLikeId: (raw: string) => Boolean(raw.trim()),
-      hint: '<channel-id> e.g. ch-001',
-    },
-  },
-
-  outbound: {
-    deliveryMode: 'direct',
-    chunkerMode: 'text',
-    textChunkLimit: 3000,
-
-    sendText: async ({ to, text }: { cfg: unknown; to: string; text: string; accountId?: string }) => {
-      logger.info(`[outbound] sendText to=${to} len=${text.length}`);
-      const rt = registry.getDefault();
-      if (!rt?.isRunning) {
-        logger.warn('[outbound] sendText failed: not connected');
-        return { channel: 'openagent', ok: false, messageId: '', error: new Error('OpenAgent not connected') };
-      }
-
-      // v3.9+ 双轨抽象：群聊外发仅在 TIM 路径有效（IMChannelTransport）。
-      // OASN 路径下没有"主动发群消息"语义 —— ClientAgent 只通过 sendTask
-      // 向远端 ServiceAgent 发起 Invocation，原则上不会触达此分支；
-      // 但若上层误调用，直接告警并返回 ok=false，避免崩溃。
-      if (rt.transportType === 'oasn') {
-        logger.warn(`[outbound] sendText not supported on OASN transport (to=${to})`);
-        return {
-          channel: 'openagent',
-          ok: false,
-          messageId: '',
-          error: new Error('sendText not supported on OASN transport'),
-        };
-      }
-
-      try {
-        const result = await rt.sendMessage(to, text);
-        logger.info(`[outbound] sendText OK msgId=${result.messageId}`);
-        return { channel: 'openagent', ok: true, messageId: result.messageId };
-      } catch (err) {
-        logger.error(`[outbound] sendText failed: ${(err as Error).message}`);
-        return {
-          channel: 'openagent', ok: false, messageId: '',
-          error: err instanceof Error ? err : new Error(String(err)),
-        };
-      }
-    },
-  },
-
-  status: {
-    defaultRuntime: {
-      accountId: 'default',
-      running: false,
-      lastStartAt: null as number | null,
-      lastStopAt: null as number | null,
-      lastError: null as string | null,
-    },
-    buildChannelSummary: ({ snapshot }: { snapshot: Record<string, unknown> }) => ({
-      configured: snapshot['configured'] ?? false,
-      running: snapshot['running'] ?? false,
-      connected: snapshot['connected'] ?? false,
-      transport: snapshot['transport'] ?? 'oasn',
-      claimStatus: snapshot['claimStatus'] ?? 'unknown',
-      claimUrl: snapshot['claimUrl'] ?? '',
-      lastStartAt: snapshot['lastStartAt'] ?? null,
-      lastStopAt: snapshot['lastStopAt'] ?? null,
-      lastError: snapshot['lastError'] ?? null,
-      lastInboundAt: snapshot['lastInboundAt'] ?? null,
-      lastOutboundAt: snapshot['lastOutboundAt'] ?? null,
-    }),
-    probeAccount: async () => ({ ok: true }),
-    buildAccountSnapshot: ({ account, runtime }: {
-      account: { accountId: string; name: string; enabled: boolean; configured: boolean; transport?: string; status?: string; claimUrl?: string };
-      runtime?: { running?: boolean; lastStartAt?: number; lastStopAt?: number; lastError?: string };
-    }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      tokenStatus: account.configured ? 'available' : 'missing',
-      transport: account.transport ?? 'oasn',
-      claimStatus: runtime && 'claimStatus' in runtime ? (runtime as { claimStatus?: string }).claimStatus : account.status ?? 'unknown',
-      claimUrl: account.claimUrl ?? '',
-      running: runtime?.running ?? false,
-      connected: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-    }),
-
-    // Outbound handlers: intentionally no-op (LLM text is intercepted here)
-    sendText: async () => ({ ok: true }),
-    sendMedia: async () => ({ ok: true }),
-  },
-
-    // ── Gateway lifecycle ──
-  gateway: {
-    startAccount: async (ctx: {
-      account: {
-        accountId: string;
-        agentId: string;
-        apiBase: string;
-        accessApiBase?: string;
-        apiKey: string;
-        configured: boolean;
-        config: Record<string, unknown>;
-      };
-      cfg: Record<string, unknown>;
-      abortSignal?: AbortSignal;
-      log?: { info?: (msg: string) => void; warn?: (msg: string) => void; error?: (msg: string) => void };
-      setStatus: (status: Record<string, unknown>) => void;
-    }) => {
-      const { account, abortSignal } = ctx;
-
-      // Guard is installed in register() (index.ts), not here.
-
-      // OASN 模式以 CLI install/register/write-config 为首次注册入口。
-      // runtime 只消费已经写入的 agent_id + api_key。
-      const accountConfig = resolveOpenagentAccount(ctx.cfg);
-      if (accountConfig.transport === 'oasn' && isUnconfiguredOasnApiBase(accountConfig.apiBase)) {
-        logger.warn('[channel] OASN api_base not configured; skipping start');
-        ctx.setStatus({
-          accountId: account.accountId,
-          running: false,
-          configured: false,
-          transport: 'oasn',
-          claimStatus: accountConfig.status,
-          lastError: 'OASN api_base is not configured',
-        });
-        return;
-      }
-      if (accountConfig.transport === 'oasn' && !accountConfig.configured) {
-        const message = 'OASN account is not configured; run openclaw-plugin-openagent-cli install to register this device';
-        logger.warn(`[channel] ${message}`);
-        ctx.setStatus({
-          accountId: account.accountId,
-          running: false,
-          configured: false,
-          transport: 'oasn',
-          claimStatus: accountConfig.status,
-          claimUrl: accountConfig.claimUrl,
-          lastError: message,
-        });
-        return;
-      }
-      if (!account.configured && accountConfig.transport !== 'oasn') {
-        logger.warn('[channel] Not configured; skipping');
-        ctx.setStatus({ accountId: account.accountId, running: false, configured: false });
-        return;
-      }
-
-      logger.info(`[channel] Starting account '${account.accountId}' for agent ${accountConfig.agentId || account.agentId || '(unconfigured)'}`);
-
-      const runtime = new AccountRuntime(account.accountId);
-
-      try {
-        // Register in registry (throws if another account is active)
-        registry.register(runtime);
-
-        // Transaction-style start
-        await runtime.start(
-          {
-            accountId: account.accountId,
-            name: 'OpenAgent',
-            enabled: true,
-            configured: accountConfig.configured,
-            agentId: accountConfig.agentId,
-            apiKey: accountConfig.apiKey,
-            apiBase: accountConfig.apiBase,
-            accessApiBase: accountConfig.accessApiBase,
-            claimUrl: accountConfig.claimUrl,
-            status: accountConfig.status,
-            registeredAt: accountConfig.registeredAt,
-            // v3.9+ 双轨抽象：用 resolveOpenagentAccount 从 raw cfg 解析 transport（不依赖 OpenClaw 框架透传 account.config 自定义字段）
-            transport: accountConfig.transport,
-            config: account.config || {},
-          },
-          {
-            batchWindowMs: (account.config?.['batchWindowMs'] as number) || 20_000,
-            maxBatchSize: (account.config?.['maxBatchSize'] as number) || 20,
-          },
-          ctx.cfg,
-        );
-
-        ctx.setStatus({
-          accountId: account.accountId,
-          running: true,
-          configured: accountConfig.configured,
-          transport: runtime.transportType,
-          claimStatus: runtime.claimStatus,
-          claimUrl: runtime.claimUrl,
-          lastStartAt: Date.now(),
-        });
-
-        logger.info('[channel] Pipeline active: Push mode');
-
-        // Block until aborted
-        await new Promise<void>((_, reject) => {
-          if (abortSignal) {
-            abortSignal.addEventListener('abort', () => {
-              void runtime.stop().then(() => {
-                registry.unregister(runtime);
-                ctx.setStatus({
-                  accountId: account.accountId,
-                  running: false,
-                  lastStopAt: Date.now(),
-                });
-                logger.info(`[channel] Account '${account.accountId}' stopped via abort`);
-                reject(new Error('abort'));
-              });
-            }, { once: true });
-          }
-        });
-      } catch (err) {
-        // Controlled failure: catch registry error or start error
-        const message = (err as Error).message;
-        if (message !== 'abort') {
-          logger.error(`[channel] Start failed: ${message}`);
-          registry.unregister(runtime);
-          ctx.setStatus({
-            accountId: account.accountId,
-            running: false,
-            lastError: message,
-          });
-        }
-      }
-    },
-
-    stopAccount: async (ctx: {
-      account: { accountId: string };
-      setStatus: (status: Record<string, unknown>) => void;
-    }) => {
-      const rt = registry.getDefault();
-      if (rt) {
-        await rt.stop();
-        registry.unregister(rt);
-      }
-      ctx.setStatus({
-        accountId: ctx.account.accountId,
-        running: false,
-        lastStopAt: Date.now(),
-      });
-    },
-  },
-
-  // ── Onboarding wizard ──
-  onboarding: {
-    channel: 'openagent',
-    getStatus: async ({ cfg }: { cfg: Record<string, unknown> }) => {
-      const account = resolveOpenagentAccount(cfg);
-      const apiBaseMissing = account.transport === 'oasn' && isUnconfiguredOasnApiBase(account.apiBase);
-      const statusLine = buildOnboardingStatusLine(account, apiBaseMissing);
-      return {
-        channel: 'openagent',
-        configured: account.transport === 'oasn' ? account.configured && !apiBaseMissing : account.configured,
-        statusLines: [statusLine],
-        selectionHint: apiBaseMissing
-          ? 'needs api_base'
-          : account.transport === 'oasn' && !account.configured
-            ? 'needs CLI install'
-            : account.configured ? 'configured' : 'needs credentials',
-        quickstartScore: apiBaseMissing ? 0 : account.configured ? 2 : 0,
-      };
-    },
-    configure: async ({ cfg, prompter }: {
-      cfg: Record<string, unknown>;
-      prompter: { text: (opts: { message: string; validate: (v: string) => string | undefined }) => Promise<string> };
-    }) => {
-      const existing = ((cfg['channels'] as Record<string, unknown>)?.['openagent'] || {}) as Record<string, unknown>;
-      const accounts = (existing['accounts'] || {}) as Record<string, Record<string, unknown>>;
-      const firstAccKey = Object.keys(accounts)[0];
-      const fallbackAcc = firstAccKey ? accounts[firstAccKey]! : {};
-      const resolved = resolveOpenagentAccount(cfg);
-
-      if (resolved.transport === OASN_TRANSPORT) {
-        let apiBase = resolved.apiBase;
-        if (isUnconfiguredOasnApiBase(apiBase)) {
-          apiBase = String(await prompter.text({
-            message: 'Enter OASN API Base URL',
-            validate: (v: string) => {
-              const value = v?.trim();
-              if (!value || isUnconfiguredOasnApiBase(value)) return 'Required';
-              try {
-                // eslint-disable-next-line no-new
-                new URL(value);
-                return undefined;
-              } catch {
-                return 'Must be a valid URL';
-              }
-            },
-          })).trim();
-        }
-        const accessApiBase = String(
-          resolved.accessApiBase
-          || fallbackAcc['access_api_base']
-          || fallbackAcc['accessApiBase']
-          || existing['access_api_base']
-          || existing['accessApiBase']
-          || apiBase,
-        );
-
-        let claimUpdates: Record<string, unknown> = {};
-        if (resolved.agentId && resolved.apiKey && resolved.status !== 'claimed') {
-          const ownerEmail = String(await prompter.text({
-            message: 'Enter Owner email to claim this OASN ClientAgent (leave blank to skip)',
-            validate: () => undefined,
-          })).trim();
-          if (ownerEmail) {
-            claimUpdates = await claimOasnAgent(apiBase, resolved.apiKey, resolved.agentId, ownerEmail);
-          }
-        }
-
-        return {
-          cfg: {
-            ...cfg,
-            channels: {
-              ...(cfg['channels'] as Record<string, unknown>),
-              openagent: {
-                ...existing,
-                enabled: true,
-                transport: 'oasn',
-                api_base: apiBase,
-                access_api_base: accessApiBase,
-                accounts: {
-                  default: compactConfig({
-                    ...fallbackAcc,
-                    transport: 'oasn',
-                    api_base: apiBase,
-                    access_api_base: accessApiBase,
-                    agent_id: resolved.agentId || fallbackAcc['agent_id'],
-                    api_key: resolved.apiKey || fallbackAcc['api_key'],
-                    claim_url: resolved.claimUrl || fallbackAcc['claim_url'],
-                    status: claimUpdates.status || resolved.status,
-                    registered_at: resolved.registeredAt || fallbackAcc['registered_at'],
-                    ...claimUpdates,
-                  }),
-                },
-              },
-            },
-          },
-          accountId: 'default',
-        };
-      }
-
-      let agentId = (fallbackAcc['agentId'] || fallbackAcc['agent_id'] || firstAccKey || '') as string;
-      let apiKey = (fallbackAcc['api_key'] || fallbackAcc['apiKey'] || '') as string;
-      const apiBase = (fallbackAcc['apiBase'] || fallbackAcc['api_base'] || API_BASE) as string;
-
-      if (!agentId) {
-        agentId = String(await prompter.text({
-          message: 'Enter your OpenAgent Agent ID',
-          validate: (v: string) => v?.trim() ? undefined : 'Required',
-        })).trim();
-      }
-
-      if (!apiKey) {
-        apiKey = String(await prompter.text({
-          message: 'Enter your OpenAgent API Key',
-          validate: (v: string) => v?.trim() ? undefined : 'Required',
-        })).trim();
-      }
-
-      const cleanedExisting = { ...existing };
-      delete cleanedExisting['agentId'];
-      delete cleanedExisting['apiKey'];
-      delete cleanedExisting['agent_id'];
-      delete cleanedExisting['api_key'];
-
-      return {
-        cfg: {
-          ...cfg,
-          channels: {
-            ...(cfg['channels'] as Record<string, unknown>),
-            openagent: {
-              ...cleanedExisting,
-              enabled: true,
-              accounts: {
-                default: {
-                  agent_id: agentId,
-                  api_key: apiKey,
-                  api_base: apiBase,
-                },
-              },
-            },
-          },
-        },
-        accountId: 'default',
-      };
-    },
-    disable: (cfg: Record<string, unknown>) => ({
-      ...cfg,
-      channels: {
-        ...(cfg['channels'] as Record<string, unknown>),
-        openagent: {
-          ...((cfg['channels'] as Record<string, unknown>)?.['openagent'] as Record<string, unknown>),
-          enabled: false,
-        },
-      },
-    }),
-  },
-};
-
-function buildOnboardingStatusLine(
-  account: ReturnType<typeof resolveOpenagentAccount>,
-  apiBaseMissing: boolean,
-): string {
-  if (account.transport !== 'oasn') {
-    return account.configured
-      ? `OpenAgent: configured (agent=${account.agentId})`
-      : 'OpenAgent: needs agentId + apiKey';
-  }
-  if (apiBaseMissing) return 'OASN: needs api_base';
-  if (!account.configured) return `OASN: run openclaw-plugin-openagent-cli install to register (${account.apiBase})`;
-  const claimHint = account.status === 'claimed'
-    ? 'claimed'
-    : `${account.status}${account.claimUrl ? ` claim=${account.claimUrl}` : ''}`;
-  return `OASN: ${claimHint} (agent=${account.agentId})`;
-}
-
-function compactConfig(input: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(input).filter(([, value]) => value !== undefined && value !== ''),
-  );
-}
-
-async function claimOasnAgent(
-  apiBase: string,
-  apiKey: string,
-  agentId: string,
-  ownerEmail: string,
-): Promise<Record<string, unknown>> {
-  const res = await fetch(resolveOasnRelativeUrl(apiBase, '/api/agents/claim'), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({ agentId, ownerEmail }),
-    signal: AbortSignal.timeout(15_000),
-  });
-  const body = await res.json().catch(() => ({})) as Record<string, unknown>;
-  if (!res.ok) {
-    throw new Error(`claim failed: ${res.status} ${JSON.stringify(body).slice(0, 200)}`);
-  }
-  return {
-    status: 'claim_pending',
-    claim_expires_at: body['expiresAt'] || body['expires_at'],
-    owner_email_masked: body['ownerEmailMasked'] || body['owner_email_masked'],
-  };
-}

package/src/compat.ts

@@ -1,94 +0,0 @@
-/**
- * Runtime host-version compatibility check for openclaw-openagent.
- *
- * OpenClaw uses a date-based version format: YYYY.M.DD (e.g. 2026.3.22).
- * This module parses that format and validates the running host is within
- * the supported range for this plugin version.
- *
- * Ported from openclaw-weixin v2.1.1 src/compat.ts
- * Reference: docs/reference/plugins/openclaw-weixin-latest-v2.1.1/src/compat.ts
- */
-
-import { logger } from './util/logger.js';
-
-export const PLUGIN_VERSION = '1.0.0';
-
-export const SUPPORTED_HOST_MIN = '2026.3.22';
-
-/** Plugin has been verified up to this OpenClaw host version */
-export const MAX_TESTED_VERSION = '2026.6.30';
-
-export interface OpenClawVersion {
-  year: number;
-  month: number;
-  day: number;
-}
-
-/**
- * Parse an OpenClaw date version string (e.g. "2026.3.22") into components.
- * Returns null for unparseable strings.
- */
-export function parseOpenClawVersion(version: string): OpenClawVersion | null {
-  // Strip any pre-release suffix (e.g. "2026.3.22-beta.1" -> "2026.3.22")
-  const base = version.trim().split('-')[0];
-  const parts = base.split('.');
-  if (parts.length !== 3) return null;
-  const [year, month, day] = parts.map(Number);
-  if (Number.isNaN(year) || Number.isNaN(month) || Number.isNaN(day)) return null;
-  return { year, month, day };
-}
-
-/**
- * Compare two parsed versions. Returns -1 | 0 | 1.
- */
-export function compareVersions(a: OpenClawVersion, b: OpenClawVersion): -1 | 0 | 1 {
-  for (const key of ['year', 'month', 'day'] as const) {
-    if (a[key] < b[key]) return -1;
-    if (a[key] > b[key]) return 1;
-  }
-  return 0;
-}
-
-/**
- * Check whether a host version string is >= SUPPORTED_HOST_MIN.
- */
-export function isHostVersionSupported(hostVersion: string): boolean {
-  const host = parseOpenClawVersion(hostVersion);
-  if (!host) return false;
-  const min = parseOpenClawVersion(SUPPORTED_HOST_MIN)!;
-  return compareVersions(host, min) >= 0;
-}
-
-/**
- * Fail-fast guard. Call at the very start of `register()` to prevent the
- * plugin from loading on an incompatible host.
- *
- * @throws {Error} with a human-readable message when the host is out of range.
- */
-export function assertHostCompatibility(hostVersion: string | undefined): void {
-  if (!hostVersion || hostVersion === 'unknown') {
-    logger.warn(
-      '[compat] Could not determine host OpenClaw version; skipping compatibility check.',
-    );
-    return;
-  }
-  if (isHostVersionSupported(hostVersion)) {
-    logger.info(`[compat] Host OpenClaw ${hostVersion} >= ${SUPPORTED_HOST_MIN}, OK.`);
-    // Warn but don't block for versions beyond tested range
-    const host = parseOpenClawVersion(hostVersion);
-    const max = parseOpenClawVersion(MAX_TESTED_VERSION);
-    if (host && max && compareVersions(host, max) > 0) {
-      logger.warn(
-        `[compat] Host OpenClaw ${hostVersion} is beyond max tested version ${MAX_TESTED_VERSION}. ` +
-        `The plugin may encounter compatibility issues.`,
-      );
-    }
-    return;
-  }
-  throw new Error(
-    `openclaw-openagent@${PLUGIN_VERSION} requires OpenClaw >=${SUPPORTED_HOST_MIN}, ` +
-    `but found ${hostVersion}. ` +
-    `Please upgrade OpenClaw, or install the legacy version:\n` +
-    `  npm install openclaw-openagent@legacy`,
-  );
-}

package/src/config/config-schema.ts

@@ -1,39 +0,0 @@
-/**
- * OpenAgent config schema — Zod-based runtime validation.
- *
- * This mirrors the JSON schema in openclaw.plugin.json but provides
- * type-safe runtime parsing via Zod.
- *
- * Uses direct zod dependency (same pattern as openclaw-weixin v2.1.1)
- * rather than openclaw/plugin-sdk/zod, which is only available in
- * OpenClaw >= ~2026.3.28 and would break on earlier supported hosts.
- */
-
-import { z } from 'zod';
-
-// ---------------------------------------------------------------------------
-// Zod config schema
-// ---------------------------------------------------------------------------
-
-const transportSchema = z.enum(['oasn', 'tim']).default('oasn');
-
-const openagentAccountSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-  transport: transportSchema.optional(),
-  agent_id: z.string().optional(),
-  api_key: z.string().optional(),
-  api_base: z.string().optional(),
-  access_api_base: z.string().optional(),
-  claim_url: z.string().optional(),
-  status: z.enum(['unregistered', 'unclaimed', 'claim_pending', 'claimed', 'credential_expired', 'unknown']).optional(),
-  registered_at: z.string().optional(),
-});
-
-/** Top-level openagent config schema. */
-export const OpenagentConfigSchema = openagentAccountSchema.extend({
-  transport: transportSchema.optional(),
-  api_base: z.string().optional(),
-  access_api_base: z.string().optional(),
-  accounts: z.record(z.string(), openagentAccountSchema).optional(),
-});