@twsxtd/hapi-openclaw 0.1.0 → 0.1.1

package/README.md

@@ -2,14 +2,17 @@
 
 Native OpenClaw plugin adapter for HAPI integration work.
 
-This package now installs as an OpenClaw native plugin and exposes the HAPI-facing `/hapi/*` route surface from inside the OpenClaw Gateway. The command runtime is still mock-backed for now, but the package can already capture real OpenClaw transcript update payloads through a native plugin service.
+This package installs as an OpenClaw native plugin and exposes the HAPI-facing `/hapi/*` route surface from inside the OpenClaw Gateway. V1 now creates or resumes real OpenClaw sessions, starts real embedded-agent runs, and forwards real assistant transcript messages back into HAPI. Approval bridging is still deferred.
 
 What it does:
 
 - exposes `/hapi/health` and `/hapi/channel/*` through `api.registerHttpRoute(...)`
 - enforces plugin-managed bearer auth
 - signs callback events back to HAPI
-- emits deterministic mock assistant and approval events for now
+- derives deterministic OpenClaw session keys from HAPI namespace + user key
+- starts real OpenClaw embedded-agent runs for `send-message`
+- bridges assistant transcript text updates into HAPI `message` / `state` callbacks
+- returns `501` for approval endpoints until the real approval bridge lands
 - records real transcript-update payloads to plugin state when `prototypeCaptureSessionKey` is configured
 
 Plugin config lives under `plugins.entries.hapi-openclaw.config` in OpenClaw config:
@@ -53,7 +56,7 @@ Example OpenClaw config:
                     "hapiBaseUrl": "http://127.0.0.1:3006",
                     "sharedSecret": "test-secret",
                     "namespace": "default",
-                    "prototypeCaptureSessionKey": "hapi-openclaw:default:debug-user"
+                    "prototypeCaptureSessionKey": "agent:main:hapi-openclaw:default:debug-user"
                 }
             }
         }
@@ -65,4 +68,6 @@ Current milestone note:
 
 - HAPI official mode should point `OPENCLAW_PLUGIN_BASE_URL` at the OpenClaw Gateway base URL
 - the plugin route surface is native now
-- the real OpenClaw run/approval adapter is still not implemented; command behavior is still backed by the mock runtime
+- `ensure-default-conversation` and `send-message` use the real OpenClaw runtime now
+- assistant replies in HAPI come from real OpenClaw transcript updates, not mock text
+- approval request / approve / deny bridging is still not implemented in this milestone

package/dist/index.js

@@ -163,6 +163,233 @@ async function forwardNodeRequestToHono(app, req, res) {
   return true;
 }
 
+// src/openclawAdapter.ts
+import { randomUUID } from "node:crypto";
+
+// src/adapterState.ts
+var activeRuns = new Set;
+var seenTranscriptMessageIds = new Set;
+var adapterState = {
+  startRun(sessionKey) {
+    if (activeRuns.has(sessionKey)) {
+      return false;
+    }
+    activeRuns.add(sessionKey);
+    return true;
+  },
+  isRunActive(sessionKey) {
+    return activeRuns.has(sessionKey);
+  },
+  finishRun(sessionKey) {
+    return activeRuns.delete(sessionKey);
+  },
+  rememberTranscriptMessage(messageId) {
+    if (seenTranscriptMessageIds.has(messageId)) {
+      return false;
+    }
+    seenTranscriptMessageIds.add(messageId);
+    return true;
+  },
+  resetForTests() {
+    activeRuns.clear();
+    seenTranscriptMessageIds.clear();
+  }
+};
+
+// src/sessionKeys.ts
+import { createHash } from "node:crypto";
+var HAPI_SESSION_PREFIX = "hapi-openclaw";
+var DEFAULT_AGENT_ID = "main";
+var REPLY_TO_CURRENT_PREFIX = "[[reply_to_current]]";
+function encodeUserKey(externalUserKey) {
+  const normalized = externalUserKey.trim();
+  if (!normalized) {
+    throw new Error("externalUserKey must be a non-empty string");
+  }
+  return encodeURIComponent(normalized);
+}
+function getDefaultAgentId() {
+  return DEFAULT_AGENT_ID;
+}
+function buildHapiConversationToken(namespace, externalUserKey) {
+  return `${HAPI_SESSION_PREFIX}:${namespace}:${encodeUserKey(externalUserKey)}`;
+}
+function buildHapiSessionKey(namespace, externalUserKey, agentId = DEFAULT_AGENT_ID) {
+  return `agent:${agentId}:${buildHapiConversationToken(namespace, externalUserKey)}`;
+}
+function parseHapiSessionKey(sessionKey) {
+  if (!sessionKey) {
+    return null;
+  }
+  const match = /^agent:([^:]+):hapi-openclaw:([^:]+):(.+)$/.exec(sessionKey.trim());
+  if (!match) {
+    return null;
+  }
+  try {
+    return {
+      agentId: match[1],
+      namespace: match[2],
+      externalUserKey: decodeURIComponent(match[3])
+    };
+  } catch {
+    return null;
+  }
+}
+function deriveDeterministicSessionId(sessionKey) {
+  const hex = createHash("sha256").update(sessionKey).digest("hex").slice(0, 32);
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+function stripReplyToCurrentPrefix(text) {
+  return text.replace(new RegExp(`^${REPLY_TO_CURRENT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*`), "").trim();
+}
+
+// src/openclawAdapter.ts
+var CONVERSATION_TITLE = "OpenClaw";
+var RUN_COMPLETION_SETTLE_MS = 50;
+
+class ConversationBusyError extends Error {
+  constructor() {
+    super("Conversation already has an active OpenClaw run");
+  }
+}
+function createStateEvent(params) {
+  return {
+    type: "state",
+    eventId: randomUUID(),
+    occurredAt: Date.now(),
+    namespace: params.namespace,
+    conversationId: params.conversationId,
+    connected: true,
+    thinking: params.thinking,
+    lastError: params.lastError
+  };
+}
+function getStateNamespace(sessionKey, fallbackNamespace) {
+  return parseHapiSessionKey(sessionKey)?.namespace ?? fallbackNamespace;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function ensureSessionBinding(runtime, sessionKey, agentId) {
+  const storePath = runtime.agent.session.resolveStorePath(undefined, { agentId });
+  const store = runtime.agent.session.loadSessionStore(storePath);
+  const existing = store[sessionKey];
+  const sessionId = existing?.sessionId?.trim() || deriveDeterministicSessionId(sessionKey);
+  const sessionFile = runtime.agent.session.resolveSessionFilePath(sessionId, existing, { agentId });
+  store[sessionKey] = {
+    ...existing,
+    sessionId,
+    sessionFile,
+    updatedAt: Date.now(),
+    label: existing?.label ?? CONVERSATION_TITLE,
+    displayName: existing?.displayName ?? CONVERSATION_TITLE
+  };
+  await runtime.agent.session.saveSessionStore(storePath, store, {
+    activeSessionKey: sessionKey
+  });
+  return {
+    sessionId,
+    sessionFile
+  };
+}
+
+class RealOpenClawAdapter {
+  namespace;
+  runtime;
+  callbackClient;
+  supportsApprovals = false;
+  constructor(namespace, runtime, callbackClient) {
+    this.namespace = namespace;
+    this.runtime = runtime;
+    this.callbackClient = callbackClient;
+  }
+  async ensureDefaultConversation(externalUserKey) {
+    return {
+      conversationId: buildHapiSessionKey(this.namespace, externalUserKey, getDefaultAgentId()),
+      title: CONVERSATION_TITLE
+    };
+  }
+  isConversationBusy(conversationId) {
+    return adapterState.isRunActive(conversationId);
+  }
+  async sendMessage(action) {
+    if (!adapterState.startRun(action.conversationId)) {
+      throw new ConversationBusyError;
+    }
+    const namespace = getStateNamespace(action.conversationId, this.namespace);
+    await this.callbackClient.postEvent(createStateEvent({
+      namespace,
+      conversationId: action.conversationId,
+      thinking: true,
+      lastError: null
+    }));
+    try {
+      const config = this.runtime.config.loadConfig();
+      const agentId = parseHapiSessionKey(action.conversationId)?.agentId ?? getDefaultAgentId();
+      const workspaceDir = this.runtime.agent.resolveAgentWorkspaceDir(config, agentId);
+      await this.runtime.agent.ensureAgentWorkspace({ dir: workspaceDir });
+      const { sessionId, sessionFile } = await ensureSessionBinding(this.runtime, action.conversationId, agentId);
+      const result = await this.runtime.agent.runEmbeddedAgent({
+        sessionId,
+        sessionKey: action.conversationId,
+        sessionFile,
+        workspaceDir,
+        agentId,
+        prompt: action.text,
+        timeoutMs: this.runtime.agent.resolveAgentTimeoutMs({ cfg: config }),
+        runId: randomUUID(),
+        trigger: "user"
+      });
+      const runError = result.meta.error?.message?.trim() || null;
+      if (runError) {
+        if (adapterState.finishRun(action.conversationId)) {
+          await this.callbackClient.postEvent(createStateEvent({
+            namespace,
+            conversationId: action.conversationId,
+            thinking: false,
+            lastError: runError
+          }));
+        }
+        return;
+      }
+      if (result.meta.finalAssistantVisibleText) {
+        await delay(RUN_COMPLETION_SETTLE_MS);
+      }
+      if (adapterState.finishRun(action.conversationId)) {
+        await this.callbackClient.postEvent(createStateEvent({
+          namespace,
+          conversationId: action.conversationId,
+          thinking: false,
+          lastError: null
+        }));
+      }
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "OpenClaw embedded run failed";
+      if (adapterState.finishRun(action.conversationId)) {
+        await this.callbackClient.postEvent(createStateEvent({
+          namespace,
+          conversationId: action.conversationId,
+          thinking: false,
+          lastError: message
+        }));
+      }
+      throw error2;
+    }
+  }
+  async approve(_action) {
+    throw new Error("Real OpenClaw approval bridge is not implemented yet");
+  }
+  async deny(_action) {
+    throw new Error("Real OpenClaw approval bridge is not implemented yet");
+  }
+}
+
 // ../node_modules/.bun/openclaw@2026.4.11+63c81f13a188c8c3/node_modules/openclaw/dist/runtime-store-B1YLS6z5.js
 function createPluginRuntimeStore(errorMessage) {
   let runtime = null;
@@ -187,6 +414,156 @@ function createPluginRuntimeStore(errorMessage) {
 // src/runtimeStore.ts
 var runtimeStore = createPluginRuntimeStore("OpenClaw plugin runtime is not available outside native plugin registration");
 
+// src/signing.ts
+import { createHmac } from "node:crypto";
+function signCallbackBody(timestamp, rawBody, secret) {
+  return createHmac("sha256", secret).update(`${timestamp}.${rawBody}`).digest("hex");
+}
+
+// src/hapiClient.ts
+class HapiCallbackClient {
+  hapiBaseUrl;
+  sharedSecret;
+  constructor(hapiBaseUrl, sharedSecret) {
+    this.hapiBaseUrl = hapiBaseUrl;
+    this.sharedSecret = sharedSecret;
+  }
+  async postEvent(event) {
+    const rawBody = JSON.stringify(event);
+    const timestamp = Date.now();
+    const signature = signCallbackBody(timestamp, rawBody, this.sharedSecret);
+    const response = await fetch(new URL("/api/openclaw/channel/events", this.hapiBaseUrl).toString(), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-openclaw-timestamp": `${timestamp}`,
+        "x-openclaw-signature": signature
+      },
+      body: rawBody
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      const detail = text ? `: ${text}` : "";
+      throw new Error(`HAPI callback failed with HTTP ${response.status}${detail}`);
+    }
+  }
+}
+
+// src/transcriptEvents.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractAssistantText(content) {
+  if (typeof content === "string") {
+    const normalized = stripReplyToCurrentPrefix(content);
+    return normalized.length > 0 ? normalized : null;
+  }
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const texts = content.flatMap((entry) => {
+    if (!isRecord2(entry)) {
+      return [];
+    }
+    const block = entry;
+    if (block.type !== "text" || typeof block.text !== "string") {
+      return [];
+    }
+    const normalized = stripReplyToCurrentPrefix(block.text);
+    return normalized.length > 0 ? [normalized] : [];
+  });
+  if (texts.length === 0) {
+    return null;
+  }
+  return texts.join(`
+
+`);
+}
+function normalizeAssistantTranscriptEvent(update) {
+  const parsed = parseHapiSessionKey(update.sessionKey);
+  if (!parsed || !isRecord2(update.message)) {
+    return null;
+  }
+  const message = update.message;
+  if (message.role !== "assistant") {
+    return null;
+  }
+  const text = extractAssistantText(message.content);
+  if (!text) {
+    return null;
+  }
+  const externalMessageId = typeof update.messageId === "string" && update.messageId.length > 0 ? update.messageId : typeof message.responseId === "string" && message.responseId.length > 0 ? message.responseId : null;
+  if (!externalMessageId) {
+    return null;
+  }
+  const createdAt = typeof message.timestamp === "number" && Number.isFinite(message.timestamp) ? message.timestamp : Date.now();
+  return {
+    type: "message",
+    eventId: `message:${externalMessageId}`,
+    occurredAt: createdAt,
+    namespace: parsed.namespace,
+    conversationId: update.sessionKey,
+    externalMessageId,
+    role: "assistant",
+    content: {
+      mode: "replace",
+      text
+    },
+    createdAt,
+    status: "completed"
+  };
+}
+
+// src/transcriptBridge.ts
+async function handleTranscriptUpdate(ctx, callbackClient, update) {
+  const event = normalizeAssistantTranscriptEvent(update);
+  if (!event) {
+    return;
+  }
+  if (!adapterState.rememberTranscriptMessage(event.externalMessageId)) {
+    return;
+  }
+  await callbackClient.postEvent(event);
+  if (adapterState.finishRun(event.conversationId)) {
+    await callbackClient.postEvent({
+      type: "state",
+      eventId: `${event.eventId}:state`,
+      occurredAt: Date.now(),
+      namespace: event.namespace,
+      conversationId: event.conversationId,
+      connected: true,
+      thinking: false,
+      lastError: null
+    });
+  }
+}
+function createTranscriptBridgeService() {
+  let stopListening = null;
+  return {
+    id: `${OPENCLAW_PLUGIN_ID}:transcript-bridge`,
+    async start(ctx) {
+      const config = resolvePluginConfigFromOpenClawConfig(ctx.config);
+      if (!config) {
+        ctx.logger.warn(`Skipping ${OPENCLAW_PLUGIN_ID} transcript bridge because plugin config is unavailable`);
+        return;
+      }
+      const callbackClient = new HapiCallbackClient(config.hapiBaseUrl, config.sharedSecret);
+      const runtime = runtimeStore.getRuntime();
+      stopListening = runtime.events.onSessionTranscriptUpdate((update) => {
+        handleTranscriptUpdate(ctx, callbackClient, update).catch((error2) => {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          ctx.logger.error(`Failed to bridge transcript update: ${message}`);
+        });
+      });
+      ctx.logger.info(`Started ${OPENCLAW_PLUGIN_ID} transcript-bridge service`);
+    },
+    async stop() {
+      stopListening?.();
+      stopListening = null;
+    }
+  };
+}
+
 // src/transcriptCapture.ts
 import { appendFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
@@ -238,165 +615,6 @@ function createTranscriptCaptureService() {
   };
 }
 
-// src/signing.ts
-import { createHmac } from "node:crypto";
-function signCallbackBody(timestamp, rawBody, secret) {
-  return createHmac("sha256", secret).update(`${timestamp}.${rawBody}`).digest("hex");
-}
-
-// src/hapiClient.ts
-class HapiCallbackClient {
-  hapiBaseUrl;
-  sharedSecret;
-  constructor(hapiBaseUrl, sharedSecret) {
-    this.hapiBaseUrl = hapiBaseUrl;
-    this.sharedSecret = sharedSecret;
-  }
-  async postEvent(event) {
-    const rawBody = JSON.stringify(event);
-    const timestamp = Date.now();
-    const signature = signCallbackBody(timestamp, rawBody, this.sharedSecret);
-    const response = await fetch(new URL("/api/openclaw/channel/events", this.hapiBaseUrl).toString(), {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-openclaw-timestamp": `${timestamp}`,
-        "x-openclaw-signature": signature
-      },
-      body: rawBody
-    });
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const detail = text ? `: ${text}` : "";
-      throw new Error(`HAPI callback failed with HTTP ${response.status}${detail}`);
-    }
-  }
-}
-
-// src/openclawRuntime.ts
-import { randomUUID } from "node:crypto";
-
-class MockOpenClawRuntime {
-  namespace;
-  constructor(namespace) {
-    this.namespace = namespace;
-  }
-  ensureDefaultConversation(externalUserKey) {
-    return {
-      conversationId: `openclaw-plugin:${externalUserKey}`,
-      title: "OpenClaw"
-    };
-  }
-  run(action) {
-    const now = Date.now();
-    if (action.kind === "send-message") {
-      if (action.text.toLowerCase().includes("approval")) {
-        const requestId = `approval:${randomUUID()}`;
-        return [
-          {
-            type: "state",
-            eventId: randomUUID(),
-            occurredAt: now,
-            namespace: this.namespace,
-            conversationId: action.conversationId,
-            connected: true,
-            thinking: true,
-            lastError: null
-          },
-          {
-            type: "approval-request",
-            eventId: randomUUID(),
-            occurredAt: now + 1,
-            namespace: this.namespace,
-            conversationId: action.conversationId,
-            requestId,
-            title: "Approve OpenClaw action",
-            description: action.text,
-            createdAt: now + 1
-          },
-          {
-            type: "state",
-            eventId: randomUUID(),
-            occurredAt: now + 2,
-            namespace: this.namespace,
-            conversationId: action.conversationId,
-            connected: true,
-            thinking: false,
-            lastError: null
-          }
-        ];
-      }
-      const externalMessageId = `assistant:${randomUUID()}`;
-      return [
-        {
-          type: "state",
-          eventId: randomUUID(),
-          occurredAt: now,
-          namespace: this.namespace,
-          conversationId: action.conversationId,
-          connected: true,
-          thinking: true,
-          lastError: null
-        },
-        {
-          type: "message",
-          eventId: randomUUID(),
-          occurredAt: now + 1,
-          namespace: this.namespace,
-          conversationId: action.conversationId,
-          externalMessageId,
-          role: "assistant",
-          content: { mode: "replace", text: "OpenClaw plugin echo: " },
-          createdAt: now + 1,
-          status: "streaming"
-        },
-        {
-          type: "message",
-          eventId: randomUUID(),
-          occurredAt: now + 2,
-          namespace: this.namespace,
-          conversationId: action.conversationId,
-          externalMessageId,
-          role: "assistant",
-          content: { mode: "append", delta: action.text.trim() || "(empty message)" },
-          createdAt: now + 2,
-          status: "completed"
-        },
-        {
-          type: "state",
-          eventId: randomUUID(),
-          occurredAt: now + 3,
-          namespace: this.namespace,
-          conversationId: action.conversationId,
-          connected: true,
-          thinking: false,
-          lastError: null
-        }
-      ];
-    }
-    if (action.kind === "approve") {
-      return [{
-        type: "approval-resolved",
-        eventId: randomUUID(),
-        occurredAt: now,
-        namespace: this.namespace,
-        conversationId: action.conversationId,
-        requestId: action.requestId,
-        status: "approved"
-      }];
-    }
-    return [{
-      type: "approval-resolved",
-      eventId: randomUUID(),
-      occurredAt: now,
-      namespace: this.namespace,
-      conversationId: action.conversationId,
-      requestId: action.requestId,
-      status: "denied"
-    }];
-  }
-}
-
 // src/routes.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
@@ -1927,6 +2145,12 @@ async function dispatchEvents(callbackClient, events) {
     await callbackClient.postEvent(event);
   }
 }
+async function dispatchMaybeEvents(callbackClient, maybeEvents) {
+  if (!maybeEvents || maybeEvents.length === 0) {
+    return;
+  }
+  await dispatchEvents(callbackClient, maybeEvents);
+}
 function createPluginApp(deps) {
   const app = new Hono2;
   const healthHandler = (c) => {
@@ -1956,7 +2180,7 @@ function createPluginApp(deps) {
     if (!body?.externalUserKey) {
       return c.json({ error: "Invalid body" }, 400);
     }
-    return c.json(deps.runtime.ensureDefaultConversation(body.externalUserKey));
+    return c.json(await deps.runtime.ensureDefaultConversation(body.externalUserKey));
   };
   const sendMessageHandler = async (c) => {
     const idempotencyKey = c.req.header("idempotency-key");
@@ -1971,6 +2195,12 @@ function createPluginApp(deps) {
     if (!body?.conversationId || typeof body.text !== "string" || !body.localMessageId) {
       return c.json({ error: "Invalid body" }, 400);
     }
+    if (deps.runtime.isConversationBusy?.(body.conversationId)) {
+      return c.json({
+        error: "Conversation already has an active OpenClaw run",
+        retryAfterMs: 1000
+      }, 409);
+    }
     const ack = {
       accepted: true,
       upstreamRequestId: `plugin-send:${randomUUID2()}`,
@@ -1979,16 +2209,25 @@ function createPluginApp(deps) {
     };
     deps.idempotencyCache.set(idempotencyKey, ack);
     queueMicrotask(() => {
-      dispatchEvents(deps.callbackClient, deps.runtime.run({
+      deps.runtime.sendMessage({
         kind: "send-message",
         conversationId: body.conversationId,
         text: body.text,
         localMessageId: body.localMessageId
-      }));
+      }).then(async (events) => {
+        await dispatchMaybeEvents(deps.callbackClient, events);
+      }).catch((error2) => {
+        if (error2 instanceof ConversationBusyError) {
+          return;
+        }
+      });
     });
     return c.json(ack);
   };
   const approveHandler = async (c) => {
+    if (!deps.runtime.supportsApprovals) {
+      return c.json({ error: "OpenClaw approval bridge is not implemented yet" }, 501);
+    }
     const idempotencyKey = c.req.header("idempotency-key");
     if (!idempotencyKey) {
       return c.json({ error: "Missing idempotency-key" }, 400);
@@ -2009,15 +2248,20 @@ function createPluginApp(deps) {
     };
     deps.idempotencyCache.set(idempotencyKey, ack);
     queueMicrotask(() => {
-      dispatchEvents(deps.callbackClient, deps.runtime.run({
+      deps.runtime.approve({
         kind: "approve",
         conversationId: body.conversationId,
         requestId: c.req.param("requestId")
-      }));
+      }).then(async (events) => {
+        await dispatchMaybeEvents(deps.callbackClient, events);
+      }).catch(() => {});
     });
     return c.json(ack);
   };
   const denyHandler = async (c) => {
+    if (!deps.runtime.supportsApprovals) {
+      return c.json({ error: "OpenClaw approval bridge is not implemented yet" }, 501);
+    }
     const idempotencyKey = c.req.header("idempotency-key");
     if (!idempotencyKey) {
       return c.json({ error: "Missing idempotency-key" }, 400);
@@ -2038,11 +2282,13 @@ function createPluginApp(deps) {
     };
     deps.idempotencyCache.set(idempotencyKey, ack);
     queueMicrotask(() => {
-      dispatchEvents(deps.callbackClient, deps.runtime.run({
+      deps.runtime.deny({
         kind: "deny",
         conversationId: body.conversationId,
         requestId: c.req.param("requestId")
-      }));
+      }).then(async (events) => {
+        await dispatchMaybeEvents(deps.callbackClient, events);
+      }).catch(() => {});
     });
     return c.json(ack);
   };
@@ -2057,7 +2303,7 @@ function createPluginApp(deps) {
 function registerPluginRoutes(api) {
   const config = resolvePluginConfig(api.pluginConfig ?? {});
   const callbackClient = new HapiCallbackClient(config.hapiBaseUrl, config.sharedSecret);
-  const runtime = new MockOpenClawRuntime(config.namespace);
+  const runtime = new RealOpenClawAdapter(config.namespace, api.runtime, callbackClient);
   const app = createPluginApp({
     sharedSecret: config.sharedSecret,
     namespace: config.namespace,
@@ -2098,6 +2344,7 @@ var src_default = definePluginEntry({
     }
     runtimeStore.setRuntime(api.runtime);
     registerPluginRoutes(api);
+    api.registerService(createTranscriptBridgeService());
     api.registerService(createTranscriptCaptureService());
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@twsxtd/hapi-openclaw",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "description": "Native OpenClaw plugin that bridges HAPI to the OpenClaw Gateway route surface.",
     "license": "AGPL-3.0-only",
     "type": "module",