@soyeht/soyeht 0.2.7 → 0.2.9

package/openclaw.plugin.json

@@ -5,7 +5,7 @@
   ],
   "name": "Soyeht",
   "description": "Channel plugin for the Soyeht Flutter mobile app",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soyeht/soyeht",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "OpenClaw channel plugin for the Soyeht Flutter mobile app",
   "type": "module",
   "main": "src/index.ts",

package/src/config.ts

@@ -71,14 +71,32 @@ function readAccountsSection(
   return section?.["accounts"] as Record<string, unknown> | undefined;
 }
 
+/**
+ * Read flat config from `channels.soyeht.*` (all keys except "accounts").
+ * Used as defaults when no explicit account entry exists.
+ */
+function readFlatConfig(cfg: OpenClawConfig): Record<string, unknown> {
+  const section = readConfigSection(cfg);
+  if (!section) return {};
+  const flat: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(section)) {
+    if (key !== "accounts") {
+      flat[key] = value;
+    }
+  }
+  return flat;
+}
+
 function readAccountConfig(
   cfg: OpenClawConfig,
   accountId: string,
 ): Record<string, unknown> {
+  const flat = readFlatConfig(cfg);
   const accounts = readAccountsSection(cfg);
-  if (!accounts) return {};
-  const entry = accounts[accountId];
-  return entry && typeof entry === "object" ? (entry as Record<string, unknown>) : {};
+  const entry = accounts?.[accountId];
+  const accountRaw = entry && typeof entry === "object" ? (entry as Record<string, unknown>) : {};
+  // Merge: flat config as defaults, account-specific overrides
+  return { ...flat, ...accountRaw };
 }
 
 // ---------------------------------------------------------------------------
@@ -199,8 +217,16 @@ export function resolveSoyehtAccount(
 
 export function listSoyehtAccountIds(cfg: OpenClawConfig): string[] {
   const accounts = readAccountsSection(cfg);
-  return listConfiguredAccountIds({
+  const ids = listConfiguredAccountIds({
     accounts: accounts as Record<string, unknown> | undefined,
     normalizeAccountId,
   });
+  // If no explicit accounts but flat config exists, treat as "default" account
+  if (ids.length === 0) {
+    const flat = readFlatConfig(cfg);
+    if (Object.keys(flat).length > 0) {
+      return [DEFAULT_ACCOUNT_ID];
+    }
+  }
+  return ids;
 }

package/src/http.ts

@@ -1,7 +1,8 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi, PluginRuntimeChannel } from "openclaw/plugin-sdk";
 import { normalizeAccountId, resolveSoyehtAccount } from "./config.js";
-import { decryptEnvelopeV2, validateEnvelopeV2, type EnvelopeV2 } from "./envelope-v2.js";
+import { decryptEnvelopeV2, encryptEnvelopeV2, validateEnvelopeV2, type EnvelopeV2 } from "./envelope-v2.js";
+import { buildOutboundEnvelope } from "./outbound.js";
 import { cloneRatchetSession, zeroBuffer, type RatchetState } from "./ratchet.js";
 import type { SecurityV2Deps } from "./service.js";
 import { PLUGIN_VERSION } from "./version.js";
@@ -125,9 +126,23 @@ export function processInboundEnvelope(
 // GET /soyeht/health
 // ---------------------------------------------------------------------------
 
-export function healthHandler(_api: OpenClawPluginApi) {
+export function healthHandler(_api: OpenClawPluginApi, v2deps?: SecurityV2Deps) {
   return async (_req: IncomingMessage, res: ServerResponse) => {
-    sendJson(res, 200, { ok: true, plugin: "soyeht", version: PLUGIN_VERSION });
+    const ready = v2deps?.ready ?? false;
+    const identityLoaded = Boolean(v2deps?.identity);
+    const activeSessions = v2deps?.sessions.size ?? 0;
+    const pairedPeers = v2deps?.peers.size ?? 0;
+    const queueStats = v2deps?.outboundQueue.stats() ?? { accounts: 0, totalMessages: 0 };
+
+    sendJson(res, ready ? 200 : 503, {
+      ok: ready,
+      plugin: "soyeht",
+      version: PLUGIN_VERSION,
+      identity: identityLoaded,
+      peers: pairedPeers,
+      sessions: activeSessions,
+      queue: queueStats,
+    });
   };
 }
 
@@ -236,15 +251,38 @@ export function inboundHandler(
         return;
       }
 
-      // TODO: Push decrypted message to OpenClaw agent pipeline.
-      // The exact API depends on the OpenClaw runtime (e.g. api.channel.pushInbound()).
-      // For now the message is decrypted and the session is updated;
-      // wiring to the agent conversation will be done when the runtime API is known.
-      api.logger.info("[soyeht] Inbound message received (direct mode)", {
-        accountId: result.accountId,
-      });
+      const { plaintext, accountId } = result;
 
-      sendJson(res, 200, { ok: true, received: true, accountId: result.accountId });
+      // Parse the decrypted message (EnvelopeV2 plaintext is JSON with contentType/text)
+      let messageText: string;
+      try {
+        const parsed = JSON.parse(plaintext);
+        messageText = parsed.text ?? parsed.body ?? plaintext;
+      } catch {
+        messageText = plaintext;
+      }
+
+      api.logger.info("[soyeht] Inbound message received (direct mode)", { accountId });
+
+      // Respond 200 immediately — agent dispatch happens in background
+      sendJson(res, 200, { ok: true, received: true, accountId });
+
+      // Fire-and-forget: dispatch to agent pipeline
+      const channelRuntime = (api.runtime as Record<string, unknown>).channel as
+        | PluginRuntimeChannel
+        | undefined;
+      if (channelRuntime?.routing && channelRuntime?.reply) {
+        dispatchToAgent(api, v2deps, channelRuntime, accountId, messageText).catch((err) => {
+          api.logger.error("[soyeht] Agent dispatch failed", {
+            accountId,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        });
+      } else {
+        api.logger.warn(
+          "[soyeht] channelRuntime not available — message decrypted but not delivered to agent",
+        );
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : "unknown_error";
       sendJson(res, 400, { ok: false, error: message });
@@ -252,6 +290,119 @@ export function inboundHandler(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Dispatch inbound message to OpenClaw agent pipeline (fire-and-forget)
+// ---------------------------------------------------------------------------
+
+async function dispatchToAgent(
+  api: OpenClawPluginApi,
+  v2deps: SecurityV2Deps,
+  channelRuntime: PluginRuntimeChannel,
+  accountId: string,
+  messageText: string,
+): Promise<void> {
+  const cfg = await api.runtime.config.loadConfig();
+  const account = resolveSoyehtAccount(cfg, accountId);
+
+  const route = channelRuntime.routing.resolveAgentRoute({
+    cfg,
+    channel: "soyeht",
+    accountId: account.accountId,
+    peer: { kind: "direct", id: accountId },
+  });
+
+  const sessionCfg = (cfg as Record<string, unknown>).session as
+    | Record<string, unknown>
+    | undefined;
+  const storePath = channelRuntime.session.resolveStorePath(
+    sessionCfg?.store as string | undefined,
+    { agentId: route.agentId },
+  );
+
+  const envelopeOptions = channelRuntime.reply.resolveEnvelopeFormatOptions(cfg);
+  const previousTimestamp = channelRuntime.session.readSessionUpdatedAt({
+    storePath,
+    sessionKey: route.sessionKey,
+  });
+
+  const body = channelRuntime.reply.formatAgentEnvelope({
+    channel: "Soyeht",
+    from: `soyeht:${accountId}`,
+    timestamp: Date.now(),
+    previousTimestamp,
+    envelope: envelopeOptions,
+    body: messageText,
+  });
+
+  const ctxPayload = channelRuntime.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: messageText,
+    RawBody: messageText,
+    From: `soyeht:${accountId}`,
+    To: `soyeht:${accountId}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: "direct",
+    ConversationLabel: `soyeht:${accountId}`,
+    SenderName: accountId,
+    SenderId: accountId,
+    CommandAuthorized: true,
+    Provider: "soyeht",
+    Surface: "soyeht",
+    OriginatingChannel: "soyeht",
+    OriginatingTo: `soyeht:${accountId}`,
+  });
+
+  await channelRuntime.session.recordInboundSession({
+    storePath,
+    sessionKey: (ctxPayload as Record<string, unknown>).SessionKey as string ?? route.sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err: unknown) => {
+      api.logger.error("[soyeht] Failed updating session meta", { error: String(err) });
+    },
+  });
+
+  await channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg,
+    dispatcherOptions: {
+      deliver: async (payload: { text?: string; mediaUrl?: string }) => {
+        const text = payload.text;
+        if (!text) return;
+
+        const ratchetSession = v2deps.sessions.get(accountId);
+        if (!ratchetSession) {
+          api.logger.warn("[soyeht] No ratchet session for reply delivery", { accountId });
+          return;
+        }
+
+        const envelope = buildOutboundEnvelope(accountId, accountId, {
+          contentType: "text",
+          text,
+        });
+
+        const { envelope: v2env, updatedSession } = encryptEnvelopeV2({
+          session: ratchetSession,
+          accountId,
+          plaintext: JSON.stringify(envelope),
+          dhRatchetCfg: {
+            intervalMessages: account.security.dhRatchetIntervalMessages,
+            intervalMs: account.security.dhRatchetIntervalMs,
+          },
+        });
+        v2deps.sessions.set(accountId, updatedSession);
+        v2deps.outboundQueue.enqueue(accountId, v2env);
+      },
+      onError: (err: unknown, info: { kind: string }) => {
+        api.logger.error(`[soyeht] ${info.kind} reply failed`, {
+          accountId,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      },
+    },
+  });
+}
+
 // ---------------------------------------------------------------------------
 // GET /soyeht/events/:accountId (SSE — plugin → app outbound stream)
 // ---------------------------------------------------------------------------

package/src/index.ts

@@ -104,7 +104,7 @@ const soyehtPlugin: OpenClawPluginDefinition = {
     api.registerHttpRoute({
       path: "/soyeht/health",
       auth: "plugin",
-      handler: healthHandler(api),
+      handler: healthHandler(api, v2deps),
     });
     api.registerHttpRoute({
       path: "/soyeht/webhook/deliver",

package/src/openclaw-plugin-sdk.d.ts

@@ -140,6 +140,105 @@ declare module "openclaw/plugin-sdk" {
     sampleRate?: number;
   };
 
+  // ---- Channel runtime types (subset used by soyeht inbound dispatch) ----
+
+  export type ResolvedAgentRoute = {
+    agentId: string;
+    channel: string;
+    accountId: string;
+    sessionKey: string;
+    mainSessionKey: string;
+    lastRoutePolicy: "main" | "session";
+    matchedBy: string;
+  };
+
+  export type EnvelopeFormatOptions = {
+    timezone?: string;
+    includeTimestamp?: boolean;
+    includeElapsed?: boolean;
+    userTimezone?: string;
+  };
+
+  export type ReplyPayload = {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    isError?: boolean;
+    isReasoning?: boolean;
+    [key: string]: unknown;
+  };
+
+  export type ReplyDispatchKind = "tool" | "block" | "final";
+
+  export type PluginRuntimeChannel = {
+    routing: {
+      resolveAgentRoute: (params: {
+        cfg: OpenClawConfig;
+        channel: string;
+        accountId?: string | null;
+        peer?: { kind: ChatType; id: string } | null;
+        parentPeer?: { kind: ChatType; id: string } | null;
+        guildId?: string | null;
+        teamId?: string | null;
+        memberRoleIds?: string[];
+      }) => ResolvedAgentRoute;
+      buildAgentSessionKey: (...args: unknown[]) => string;
+    };
+    reply: {
+      finalizeInboundContext: <T extends Record<string, unknown>>(
+        ctx: T,
+        opts?: Record<string, unknown>,
+      ) => T;
+      formatAgentEnvelope: (params: {
+        channel: string;
+        from?: string;
+        timestamp?: number | Date;
+        previousTimestamp?: number | Date;
+        envelope?: EnvelopeFormatOptions;
+        body: string;
+        host?: string;
+        ip?: string;
+      }) => string;
+      resolveEnvelopeFormatOptions: (cfg?: OpenClawConfig) => EnvelopeFormatOptions;
+      dispatchReplyWithBufferedBlockDispatcher: (params: {
+        ctx: Record<string, unknown>;
+        cfg: OpenClawConfig;
+        dispatcherOptions: {
+          deliver: (
+            payload: ReplyPayload,
+            info?: { kind: ReplyDispatchKind },
+          ) => Promise<void>;
+          onError?: (err: unknown, info: { kind: string }) => void;
+          [key: string]: unknown;
+        };
+        replyOptions?: Record<string, unknown>;
+      }) => Promise<unknown>;
+      dispatchReplyFromConfig: (...args: unknown[]) => Promise<unknown>;
+      [key: string]: unknown;
+    };
+    session: {
+      resolveStorePath: (store?: string, opts?: { agentId?: string }) => string;
+      readSessionUpdatedAt: (params: {
+        storePath: string;
+        sessionKey: string;
+      }) => number | undefined;
+      recordInboundSession: (params: {
+        storePath: string;
+        sessionKey: string;
+        ctx: Record<string, unknown>;
+        onRecordError: (err: unknown) => void;
+        [key: string]: unknown;
+      }) => Promise<void>;
+      [key: string]: unknown;
+    };
+    activity: {
+      record: (...args: unknown[]) => void;
+      [key: string]: unknown;
+    };
+    text: { [key: string]: unknown };
+    [key: string]: unknown;
+  };
+
   export type PluginRuntime = {
     config: {
       loadConfig: () => Promise<OpenClawConfig>;
@@ -160,6 +259,7 @@ declare module "openclaw/plugin-sdk" {
         prefsPath?: string;
       }) => Promise<TtsTelephonyResult>;
     };
+    channel?: PluginRuntimeChannel;
     [key: string]: unknown;
   };
 

package/src/outbound-queue.ts

@@ -41,6 +41,8 @@ export type OutboundQueue = {
   prune(): number;
   clear(): void;
 
+  stats(): { accounts: number; totalMessages: number };
+
   // Stream token management (for SSE auth)
   createStreamToken(accountId: string, expiresAt: number): string;
   validateStreamToken(token: string): StreamTokenInfo | null;
@@ -217,12 +219,21 @@ export function createOutboundQueue(opts: OutboundQueueOptions = {}): OutboundQu
     }
   }
 
+  function stats(): { accounts: number; totalMessages: number } {
+    let totalMessages = 0;
+    for (const q of queues.values()) {
+      totalMessages += q.length;
+    }
+    return { accounts: queues.size, totalMessages };
+  }
+
   return {
     enqueue,
     subscribe,
     hasSubscribers,
     prune,
     clear,
+    stats,
     createStreamToken,
     validateStreamToken,
     revokeStreamTokensForAccount,

package/src/types.ts

@@ -31,54 +31,57 @@ export type SoyehtAccountConfig = {
   };
 };
 
-export const SoyehtAccountConfigSchema: JsonSchema = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    enabled: { type: "boolean" },
-    backendBaseUrl: { type: "string" },
-    pluginAuthToken: { type: "string" },
-    gatewayUrl: { type: "string" },
-    allowProactive: { type: "boolean" },
-    audio: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        transcribeInbound: { type: "boolean" },
-        ttsOutbound: { type: "boolean" },
-      },
+// Shared properties object — reused at account level and channel top level
+const accountConfigProperties: Record<string, unknown> = {
+  enabled: { type: "boolean" },
+  backendBaseUrl: { type: "string" },
+  pluginAuthToken: { type: "string" },
+  gatewayUrl: { type: "string" },
+  allowProactive: { type: "boolean" },
+  audio: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      transcribeInbound: { type: "boolean" },
+      ttsOutbound: { type: "boolean" },
     },
-    files: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        acceptInbound: { type: "boolean" },
-        maxBytes: { type: "number" },
-      },
+  },
+  files: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      acceptInbound: { type: "boolean" },
+      maxBytes: { type: "number" },
     },
-    security: {
-      type: "object",
-      additionalProperties: false,
-      properties: {
-        enabled: { type: "boolean" },
-        timestampToleranceMs: { type: "number" },
-        dhRatchetIntervalMessages: { type: "number" },
-        dhRatchetIntervalMs: { type: "number" },
-        sessionMaxAgeMs: { type: "number" },
-        rateLimit: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            maxRequests: { type: "number" },
-            windowMs: { type: "number" },
-          },
+  },
+  security: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      enabled: { type: "boolean" },
+      timestampToleranceMs: { type: "number" },
+      dhRatchetIntervalMessages: { type: "number" },
+      dhRatchetIntervalMs: { type: "number" },
+      sessionMaxAgeMs: { type: "number" },
+      rateLimit: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          maxRequests: { type: "number" },
+          windowMs: { type: "number" },
         },
       },
     },
   },
 };
 
-export type SoyehtChannelConfig = {
+export const SoyehtAccountConfigSchema: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: accountConfigProperties,
+};
+
+export type SoyehtChannelConfig = SoyehtAccountConfig & {
   accounts?: Record<string, SoyehtAccountConfig>;
 };
 
@@ -86,6 +89,9 @@ export const SoyehtChannelConfigSchema: JsonSchema = {
   type: "object",
   additionalProperties: false,
   properties: {
+    // Top-level account fields (flat config shorthand for single-account setups)
+    ...accountConfigProperties,
+    // Named accounts (multi-account support)
     accounts: {
       type: "object",
       additionalProperties: SoyehtAccountConfigSchema,

package/src/version.ts

@@ -1 +1 @@
-export const PLUGIN_VERSION = "0.2.7";
+export const PLUGIN_VERSION = "0.2.9";