@type-dot-com/type-openclaw-plugin 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Savvy Learn Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @openclaw/type
+
+OpenClaw channel plugin for [Type](https://type.chat) team chat integration via WebSocket.
+
+Connects OpenClaw agents to Type so users can mention an agent in any channel or DM and get streaming responses in real time.
+
+## Features
+
+- Duplex WebSocket connection with auto-reconnect and exponential backoff
+- Real-time token streaming (`stream_start` -> `stream_event` -> `stream_finish`)
+- Tool call/result forwarding during agent execution
+- Proactive messaging to Type channels
+
+## Installation
+
+Add the plugin path to your OpenClaw config (`~/.openclaw/openclaw.json`):
+
+```json
+{
+  "plugins": {
+    "load": {
+      "paths": ["~/.openclaw/plugins/type"]
+    }
+  }
+}
+```
+
+Then configure the channel:
+
+```json
+{
+  "channels": {
+    "type": {
+      "enabled": true,
+      "token": "ta_your_agent_token",
+      "wsUrl": "wss://your-type-server/api/agents/ws",
+      "agentId": "agent_..."
+    }
+  }
+}
+```
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `token` | Yes | Agent token from Type UI (`ta_`-prefixed) |
+| `wsUrl` | Yes | Type server WebSocket endpoint |
+| `agentId` | Yes | Agent ID from Type (shown in agent builder) |
+
+> **Note:** Set `agents.defaults.verboseDefault` to `"on"` in your OpenClaw config to enable streaming via `onPartialReply` callbacks.
+
+## Documentation
+
+See [SKILL.md](./SKILL.md) for the full protocol reference, streaming details, and troubleshooting guide.
+
+## License
+
+[MIT](./LICENSE)

package/SKILL.md

@@ -0,0 +1,130 @@
+# Type Channel Plugin for OpenClaw
+
+Connect OpenClaw agents to Type team chat via a duplex WebSocket.
+
+## Setup
+
+### 1. OpenClaw Config (`~/.openclaw/openclaw.json`)
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "verboseDefault": "on"
+    }
+  },
+  "channels": {
+    "type": {
+      "enabled": true,
+      "token": "ta_your_agent_token",
+      "wsUrl": "wss://your-type-server/api/agents/ws",
+      "agentId": "agent_..."
+    }
+  }
+}
+```
+
+**`agents.defaults.verboseDefault`** must be set to `"on"`. This enables `onToolResult` callbacks so tool outputs can be streamed to Type.
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `token` | Yes | Agent token from Type UI (`ta_`-prefixed) |
+| `wsUrl` | Yes | Type server WebSocket endpoint |
+| `agentId` | Yes | Agent ID from Type (shown in agent builder) |
+
+### 2. Plugin Registration
+
+Add to `plugins.load.paths` in your OpenClaw config:
+
+```json
+{
+  "plugins": {
+    "load": {
+      "paths": ["~/.openclaw/plugins/type"]
+    }
+  }
+}
+```
+
+## How It Works
+
+### Connection
+
+The plugin maintains a single duplex WebSocket to the Type server. All communication flows over this one connection:
+
+- **Type -> Agent**: message triggers, ping keepalive
+- **Agent -> Type**: pong, streaming responses, proactive messages
+
+The connection auto-reconnects with exponential backoff (1s base, 60s max, with jitter). Code 4000 means "replaced by another connection" and skips reconnect to avoid storms.
+
+### Message Flow
+
+1. User mentions the agent in Type (channel or DM)
+2. Type creates a streaming placeholder message and sends a `message` trigger over WS
+3. Plugin dispatches through OpenClaw's standard agent reply pipeline
+4. Agent generates response; `onPartialReply` fires with accumulated text
+5. Plugin streams deltas to Type: `stream_start` -> `stream_event` (tokens) -> `stream_finish`
+6. Type accumulates text and publishes real-time updates to connected clients
+
+### Streaming Protocol
+
+**Critical ordering**: `stream_start` must be acknowledged by the server before sending any `stream_event`. The server does async DB validation (agent run lookup, message validation) before creating stream state. Sending `stream_event` before the state exists results in "No active stream" errors.
+
+The plugin handles this with an ack gate (`StreamSession`):
+
+```
+onPartialReply(text1) -> send stream_start -> await server "success" ack
+                                            -> send stream_event(delta1)
+onPartialReply(text2) -> send stream_event(delta2)  (streamReady already resolved)
+onPartialReply(text3) -> send stream_event(delta3)
+dispatch complete     -> send stream_finish
+```
+
+The plugin sets `disableBlockStreaming: true` in `replyOptions` and uses `onPartialReply` for text streaming. Tool outputs arrive via the `deliver` callback (with `info.kind === "tool"`) and are forwarded as `tool-call` + `tool-result` stream events.
+
+## WebSocket Message Reference
+
+### Server -> Agent
+
+| Type | Description |
+|------|-------------|
+| `message` | Agent was triggered (mentioned in channel or DM) |
+| `ping` | Keepalive (reply with `pong`) |
+| `success` | Ack for a previous outbound message |
+| `error` | Error for a previous outbound message |
+
+### Agent -> Server
+
+| Type | Description |
+|------|-------------|
+| `pong` | Reply to ping |
+| `send` | Proactive message to a channel |
+| `stream_start` | Begin streaming response |
+| `stream_event` | Stream token/tool-call/tool-result |
+| `stream_finish` | End streaming response |
+
+### Stream Event Kinds
+
+| Kind | Fields | Description |
+|------|--------|-------------|
+| `token` | `text` | Text delta |
+| `tool-call` | `toolCallId, toolName, input` | Tool invocation started |
+| `tool-result` | `toolCallId, toolName, outcomes` | Tool completed |
+
+## Troubleshooting
+
+### No streaming (response arrives all at once)
+
+- Ensure `agents.defaults.verboseDefault` is `"on"` in `~/.openclaw/openclaw.json`
+- For short responses, `onPartialReply` may fire only once — this is expected
+
+### Agent doesn't respond at all
+
+- Check the gateway logs for `[type]` prefixed messages
+- Verify the WS connection is established (`[type] WebSocket connected`)
+- Confirm the agent token and agent ID match the Type UI config
+
+### Message stuck in streaming state
+
+- The connection likely dropped mid-stream before `stream_finish` was sent
+- Server auto-cancels after 30s idle timeout; agent timeout (120s default) is the final safety net

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+  "id": "type",
+  "name": "Type",
+  "description": "Type team chat integration",
+  "channels": ["type"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": { "type": "boolean" },
+      "token": { "type": "string" },
+      "wsUrl": { "type": "string" },
+      "agentId": { "type": "string" }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@type-dot-com/type-openclaw-plugin",
+  "version": "0.1.1",
+  "description": "OpenClaw channel plugin for Type team chat integration via WebSocket",
+  "type": "module",
+  "main": "src/index.ts",
+  "openclaw": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "channel": {
+      "id": "type",
+      "label": "Type",
+      "selectionLabel": "Type (Team Chat)",
+      "docsPath": "/channels/type",
+      "blurb": "Connect OpenClaw to Type team chat via WebSocket."
+    }
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "openclaw.plugin.json",
+    "SKILL.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ws": "^8.17.1",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/ws": "^8.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/config.ts

@@ -0,0 +1,63 @@
+/**
+ * Plugin Config Schema and Account Resolution
+ *
+ * Defines the configuration shape for the Type channel plugin
+ * and how to resolve account credentials from the OpenClaw config.
+ */
+
+import { z } from "zod";
+
+const typeChannelConfigSchema = z.object({
+  enabled: z.boolean().optional().default(false),
+  token: z.string().optional().default(""),
+  wsUrl: z.string().optional().default("wss://api.type.com/api/agents/ws"),
+  agentId: z.string().optional().default(""),
+});
+
+const cfgSchema = z.object({
+  channels: z
+    .object({
+      type: typeChannelConfigSchema.optional(),
+    })
+    .optional(),
+});
+
+export interface TypeAccountConfig {
+  accountId: string;
+  token: string;
+  wsUrl: string;
+  agentId: string;
+  enabled: boolean;
+}
+
+function parseTypeConfig(cfg: Record<string, unknown>) {
+  const parsed = cfgSchema.safeParse(cfg);
+  return parsed.success ? parsed.data.channels?.type : undefined;
+}
+
+/**
+ * List available account IDs from the config.
+ * Type uses a single account per plugin config.
+ */
+export function listAccountIds(cfg: Record<string, unknown>): string[] {
+  const typeConfig = parseTypeConfig(cfg);
+  if (typeConfig?.token) return ["default"];
+  return [];
+}
+
+/**
+ * Resolve account configuration from the OpenClaw global config.
+ */
+export function resolveAccount(
+  cfg: Record<string, unknown>,
+  accountId?: string,
+): TypeAccountConfig {
+  const typeConfig = parseTypeConfig(cfg);
+  return {
+    accountId: accountId ?? "default",
+    token: typeConfig?.token ?? "",
+    wsUrl: typeConfig?.wsUrl ?? "wss://api.type.com/api/agents/ws",
+    agentId: typeConfig?.agentId ?? "",
+    enabled: typeConfig?.enabled ?? false,
+  };
+}

package/src/connection.ts

@@ -0,0 +1,151 @@
+/**
+ * WebSocket Connection Manager
+ *
+ * Manages the WebSocket connection to the Type server. Handles:
+ * - Authentication via Authorization header
+ * - Automatic reconnection with exponential backoff + jitter
+ * - Ping/pong keepalive
+ * - Message sending and receiving
+ */
+
+import WebSocket from "ws";
+import {
+  type TypeInboundEvent,
+  type TypeOutboundMessage,
+  typeInboundEventSchema,
+} from "./protocol.js";
+
+const BASE_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 60000;
+
+export interface ConnectionConfig {
+  token: string;
+  wsUrl: string;
+  onMessage: (event: TypeInboundEvent) => void;
+  onConnected?: () => void;
+  onDisconnected?: () => void;
+}
+
+export class TypeConnection {
+  private ws: WebSocket | null = null;
+  private reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
+  private reconnectAttempts = 0;
+  private stopped = false;
+  private readonly config: ConnectionConfig;
+
+  constructor(config: ConnectionConfig) {
+    this.config = config;
+  }
+
+  connect(): void {
+    this.stopped = false;
+    this.doConnect();
+  }
+
+  disconnect(): void {
+    this.stopped = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+
+  send(message: TypeOutboundMessage): boolean {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  get isConnected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  // --- Internal ---
+
+  private doConnect(): void {
+    if (this.stopped) return;
+
+    const ws = new WebSocket(this.config.wsUrl, {
+      headers: {
+        Authorization: `Bearer ${this.config.token}`,
+      },
+    });
+    this.ws = ws;
+
+    ws.on("open", () => {
+      this.reconnectAttempts = 0;
+      this.config.onConnected?.();
+    });
+
+    ws.on("message", (data: WebSocket.Data) => {
+      this.handleMessage(data.toString());
+    });
+
+    ws.on("error", (err: Error) => {
+      console.error("[Type WS] Connection error:", err.message);
+    });
+
+    ws.on("close", (code: number) => {
+      this.ws = null;
+      this.config.onDisconnected?.();
+      // Code 4000 = replaced by another connection — don't reconnect (avoids storm)
+      if (!this.stopped && code !== 4000) {
+        this.scheduleReconnect();
+      }
+    });
+  }
+
+  private handleMessage(raw: string): void {
+    let json: unknown;
+    try {
+      json = JSON.parse(raw);
+    } catch {
+      console.error("[Type WS] Failed to parse message:", raw);
+      return;
+    }
+
+    const parsed = typeInboundEventSchema.safeParse(json);
+    if (!parsed.success) {
+      console.error("[Type WS] Unknown message shape:", raw);
+      return;
+    }
+
+    const msg = parsed.data;
+
+    // Handle ping internally
+    if (msg.type === "ping") {
+      this.send({ type: "pong" });
+      return;
+    }
+
+    // Forward all other events to the callback
+    this.config.onMessage(msg);
+  }
+
+  private scheduleReconnect(): void {
+    const baseDelay = Math.min(
+      BASE_RECONNECT_DELAY_MS * 2 ** this.reconnectAttempts,
+      MAX_RECONNECT_DELAY_MS,
+    );
+    // Add jitter to prevent thundering herd
+    const delay = Math.round(baseDelay * (0.5 + Math.random() * 0.5));
+    this.reconnectAttempts++;
+    console.log(
+      `[Type WS] Reconnecting in ${(delay / 1000).toFixed(1)}s (attempt ${this.reconnectAttempts})...`,
+    );
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.doConnect();
+    }, delay);
+  }
+}

package/src/index.ts

@@ -0,0 +1,192 @@
+/**
+ * OpenClaw Type Channel Plugin
+ *
+ * Registers a Type channel with OpenClaw, enabling bidirectional
+ * communication via a single duplex WebSocket connection.
+ *
+ * Follows the same pattern as openclaw-mqtt: stores api.runtime at
+ * registration time, then uses runtime.channel.reply.* to dispatch
+ * inbound messages through the standard OpenClaw agent pipeline.
+ */
+
+import { listAccountIds, resolveAccount } from "./config.js";
+import { TypeConnection } from "./connection.js";
+import {
+  handleInboundMessage,
+  type PluginRuntime,
+  rejectStreamAck,
+  resolveStreamAck,
+} from "./messageHandler.js";
+import { TypeOutboundHandler } from "./outbound.js";
+
+// Module-level runtime reference (set during register, used in gateway)
+let pluginRuntime: PluginRuntime | null = null;
+let _activeConnection: TypeConnection | null = null;
+let activeOutbound: TypeOutboundHandler | null = null;
+let connectionState: "disconnected" | "connecting" | "connected" =
+  "disconnected";
+
+const typePlugin = {
+  id: "type",
+  meta: {
+    id: "type",
+    label: "Type",
+    selectionLabel: "Type (Team Chat)",
+    docsPath: "/channels/type",
+    blurb: "Type team chat integration via WebSocket.",
+  },
+
+  capabilities: {
+    chatTypes: ["direct", "channel", "thread"] satisfies readonly string[],
+    media: false,
+    reactions: false,
+    threads: true,
+  },
+
+  config: {
+    listAccountIds: (cfg: Record<string, unknown>) => listAccountIds(cfg),
+    resolveAccount: (cfg: Record<string, unknown>, accountId?: string) =>
+      resolveAccount(cfg, accountId),
+  },
+
+  outbound: {
+    deliveryMode: "direct" satisfies string,
+    textChunkLimit: 4000,
+
+    sendText: async ({
+      to,
+      text,
+      replyToId,
+    }: {
+      to: string;
+      text: string;
+      replyToId?: string;
+    }) => {
+      if (!activeOutbound) {
+        return { ok: false, error: "Not connected" };
+      }
+      const sent = activeOutbound.sendMessage(to, text, replyToId);
+      if (!sent) {
+        return { ok: false, error: "Failed to send message" };
+      }
+      return { ok: true, channel: "type" };
+    },
+  },
+
+  gateway: {
+    startAccount: async (ctx: {
+      cfg: Record<string, unknown>;
+      accountId: string;
+      account: { token: string; wsUrl: string };
+      runtime: PluginRuntime;
+      abortSignal: AbortSignal;
+      log?: { info: (msg: string) => void; error: (msg: string) => void };
+    }) => {
+      if (connectionState !== "disconnected") {
+        ctx.log?.info(
+          `Type connection already ${connectionState}, skipping duplicate startAccount`,
+        );
+        return;
+      }
+      connectionState = "connecting";
+
+      const runtime = pluginRuntime ?? ctx.runtime;
+      const { token, wsUrl } = ctx.account;
+      const accountId = ctx.accountId;
+
+      const connection = new TypeConnection({
+        token,
+        wsUrl,
+        onMessage: (event) => {
+          if (event.type === "success") {
+            const reqType = (event as { requestType?: string }).requestType;
+            console.log(`[type] Server success: ${reqType}`);
+            if (reqType === "stream_start") {
+              resolveStreamAck();
+            }
+            return;
+          }
+          if (event.type === "error") {
+            const errEvt = event as {
+              requestType?: string;
+              error?: string;
+              details?: unknown;
+            };
+            console.error(
+              `[type] Server error: ${errEvt.requestType} — ${errEvt.error}`,
+              errEvt.details ?? "",
+            );
+            if (errEvt.requestType === "stream_start") {
+              rejectStreamAck(new Error(errEvt.error ?? "stream_start failed"));
+            }
+            return;
+          }
+
+          if (event.type !== "message") return;
+          if (!activeOutbound) return;
+
+          handleInboundMessage({
+            msg: event,
+            accountId,
+            cfg: ctx.cfg,
+            runtime,
+            outbound: activeOutbound,
+            log: ctx.log,
+          });
+        },
+        onConnected: () => {
+          connectionState = "connected";
+          ctx.log?.info("[type] WebSocket connected");
+        },
+        onDisconnected: () => {
+          connectionState = "disconnected";
+          ctx.log?.info("[type] WebSocket disconnected");
+        },
+      });
+
+      _activeConnection = connection;
+      activeOutbound = new TypeOutboundHandler(connection);
+
+      connection.connect();
+
+      await new Promise<void>((resolve) => {
+        ctx.abortSignal.addEventListener("abort", () => {
+          connectionState = "disconnected";
+          connection.disconnect();
+          _activeConnection = null;
+          activeOutbound = null;
+          resolve();
+        });
+      });
+    },
+  },
+};
+
+/**
+ * OpenClaw plugin entry point.
+ * Follows the object-with-register pattern from openclaw/plugin-sdk.
+ */
+const plugin = {
+  id: "type",
+  name: "Type",
+  description: "Type team chat integration via duplex WebSocket",
+  register(api: {
+    runtime: PluginRuntime;
+    registerChannel: (opts: { plugin: typeof typePlugin }) => void;
+  }) {
+    pluginRuntime = api.runtime;
+    api.registerChannel({ plugin: typePlugin });
+  },
+};
+
+export default plugin;
+
+export type { TypeAccountConfig } from "./config.js";
+// Re-export components for advanced usage
+export { TypeConnection } from "./connection.js";
+export { TypeOutboundHandler } from "./outbound.js";
+export type {
+  TypeInboundEvent,
+  TypeMessageEvent,
+  TypeOutboundMessage,
+} from "./protocol.js";

package/src/messageHandler.ts

@@ -0,0 +1,165 @@
+/**
+ * Inbound Message Handler
+ *
+ * Handles a single inbound message from Type: builds the OpenClaw
+ * inbound context, creates a StreamSession, and dispatches through
+ * the standard OpenClaw agent reply pipeline.
+ */
+
+import type { TypeOutboundHandler } from "./outbound.js";
+import type { TypeMessageEvent } from "./protocol.js";
+import { StreamSession } from "./streamSession.js";
+import { createToolEvents } from "./toolEvents.js";
+
+/**
+ * Minimal typing for the OpenClaw plugin SDK runtime.
+ */
+export interface PluginRuntime {
+  channel: {
+    reply: {
+      finalizeInboundContext: (
+        ctx: Record<string, unknown>,
+      ) => Record<string, unknown>;
+      dispatchReplyWithBufferedBlockDispatcher: (opts: {
+        ctx: Record<string, unknown>;
+        cfg: Record<string, unknown>;
+        dispatcherOptions: {
+          deliver: (
+            payload: { text?: string },
+            info: Record<string, unknown>,
+          ) => Promise<void>;
+          onSkip?: (payload: unknown, info: Record<string, unknown>) => void;
+          onError?: (err: unknown, info: Record<string, unknown>) => void;
+        };
+        replyOptions?: Record<string, unknown>;
+      }) => Promise<void>;
+    };
+  };
+}
+
+export interface Logger {
+  info: (msg: string) => void;
+  error: (msg: string) => void;
+}
+
+// Active stream session — one at a time per connection.
+// Exposed via resolveStreamAck / rejectStreamAck for the server
+// response handler in index.ts to call.
+let activeStreamSession: StreamSession | null = null;
+
+/**
+ * Resolve the pending stream_start ack on the active session.
+ */
+export function resolveStreamAck(): void {
+  activeStreamSession?.onAck();
+}
+
+/**
+ * Reject the pending stream_start ack on the active session.
+ */
+export function rejectStreamAck(error: Error): void {
+  activeStreamSession?.onAckError(error);
+}
+
+/**
+ * Handle a single inbound message trigger from Type.
+ */
+export function handleInboundMessage(params: {
+  msg: TypeMessageEvent;
+  accountId: string;
+  cfg: Record<string, unknown>;
+  runtime: PluginRuntime;
+  outbound: TypeOutboundHandler;
+  log?: Logger;
+}): void {
+  const { msg, accountId, cfg, runtime, outbound, log } = params;
+
+  log?.info(
+    `[type] Inbound message from ${msg.sender?.name ?? "unknown"} in ${msg.channelName ?? msg.channelId}`,
+  );
+
+  try {
+    const chatType = msg.parentMessageId ? "thread" : "channel";
+    const senderId = msg.sender?.id ?? "unknown";
+    const senderName = msg.sender?.name ?? "Unknown";
+    const messageBody = msg.content ?? "";
+
+    const ctxPayload = runtime.channel.reply.finalizeInboundContext({
+      Body: messageBody,
+      RawBody: messageBody,
+      CommandBody: messageBody,
+      CommandAuthorized: true,
+      From: `type:${senderId}`,
+      To: `type:${accountId}`,
+      SessionKey: msg.parentMessageId
+        ? `agent:main:type:${msg.parentMessageId}`
+        : `agent:main:type:${msg.channelId}:${msg.messageId}`,
+      AccountId: accountId,
+      ChatType: chatType,
+      ConversationLabel: msg.channelName ?? msg.channelId,
+      SenderName: senderName,
+      SenderId: senderId,
+      Provider: "type",
+      Surface: "type",
+      MessageSid: msg.messageId,
+      Timestamp: msg.timestamp,
+    });
+
+    const session = new StreamSession(outbound, msg.messageId);
+    activeStreamSession = session;
+
+    void runtime.channel.reply
+      .dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg,
+        dispatcherOptions: {
+          deliver: async (
+            payload: { text?: string },
+            info: Record<string, unknown>,
+          ) => {
+            // Handle tool results as native tool-call + tool-result stream
+            // events so they render as collapsible cards in Type's UI.
+            if (info.kind === "tool" && payload.text) {
+              if (session.isFailed) return;
+              const [toolCall, toolResult] = createToolEvents(payload.text);
+              session.sendToolEvent(toolCall);
+              session.sendToolEvent(toolResult);
+            }
+            // Other kinds (block, final) are no-op — onPartialReply handles text
+          },
+          onSkip: (_payload, info) => {
+            console.log(`[type] Reply skipped: ${JSON.stringify(info)}`);
+          },
+          onError: (err, info) => {
+            console.error(`[type] Reply error: ${err} ${JSON.stringify(info)}`);
+          },
+        },
+        replyOptions: {
+          disableBlockStreaming: true,
+          onPartialReply: (payload: { text?: string }) => {
+            if (!payload.text || session.isFailed) return;
+            session.sendToken(payload.text);
+          },
+        },
+      })
+      .then(() => {
+        if (session.isStarted) {
+          session.finish();
+        }
+        activeStreamSession = null;
+      })
+      .catch((err: unknown) => {
+        console.error(
+          `[type] Stream dispatch failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+        if (session.isStarted) {
+          session.finish();
+        }
+        activeStreamSession = null;
+      });
+  } catch (err) {
+    log?.error(
+      `[type] Message dispatch error: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}

package/src/outbound.ts

@@ -0,0 +1,84 @@
+/**
+ * Outbound Message Handler
+ *
+ * Wraps the WebSocket connection with typed methods for sending
+ * messages and streaming responses back to Type.
+ */
+
+import type { TypeConnection } from "./connection.js";
+
+export class TypeOutboundHandler {
+  constructor(private readonly connection: TypeConnection) {}
+
+  /**
+   * Send a non-streaming full response to a triggered message.
+   */
+  respond(messageId: string, content: string): boolean {
+    return this.connection.send({
+      type: "respond",
+      messageId,
+      content,
+    });
+  }
+
+  /**
+   * Send a proactive message to a channel.
+   */
+  sendMessage(
+    channelId: string,
+    content: string,
+    parentMessageId?: string,
+  ): boolean {
+    return this.connection.send({
+      type: "send",
+      channelId,
+      content,
+      parentMessageId,
+    });
+  }
+
+  /**
+   * Begin a streaming response for a triggered message.
+   */
+  startStream(messageId: string): boolean {
+    return this.connection.send({
+      type: "stream_start",
+      messageId,
+    });
+  }
+
+  /**
+   * Send a streaming token (text delta).
+   */
+  streamToken(messageId: string, text: string): boolean {
+    return this.connection.send({
+      type: "stream_event",
+      messageId,
+      event: { kind: "token", text },
+    });
+  }
+
+  /**
+   * Send a generic stream event (tool-call, tool-result, etc.).
+   */
+  streamEvent(
+    messageId: string,
+    event: { kind: string; [key: string]: unknown },
+  ): boolean {
+    return this.connection.send({
+      type: "stream_event",
+      messageId,
+      event,
+    });
+  }
+
+  /**
+   * Finalize a streaming response.
+   */
+  finishStream(messageId: string): boolean {
+    return this.connection.send({
+      type: "stream_finish",
+      messageId,
+    });
+  }
+}

package/src/protocol.ts

@@ -0,0 +1,108 @@
+/**
+ * Type WebSocket Protocol Types
+ *
+ * Defines the message types exchanged over the duplex WebSocket
+ * between the OpenClaw plugin and the Type server.
+ */
+
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Inbound: Type Server -> Plugin (Zod schemas + inferred types)
+// ---------------------------------------------------------------------------
+
+const typeMessageEventSchema = z.object({
+  type: z.literal("message"),
+  messageId: z.string(),
+  channelId: z.string(),
+  channelName: z.string().nullable(),
+  parentMessageId: z.string().nullable(),
+  sender: z
+    .object({
+      id: z.string(),
+      name: z.string(),
+    })
+    .nullable(),
+  content: z.string().nullable(),
+  mentionsAgent: z.boolean(),
+  timestamp: z.number(),
+});
+
+const typePingEventSchema = z.object({
+  type: z.literal("ping"),
+  timestamp: z.number(),
+});
+
+const typeSuccessEventSchema = z.object({
+  type: z.literal("success"),
+  requestType: z.string(),
+  messageId: z.string().optional(),
+});
+
+const typeErrorEventSchema = z.object({
+  type: z.literal("error"),
+  requestType: z.string(),
+  error: z.string(),
+  details: z.unknown().optional(),
+});
+
+export const typeInboundEventSchema = z.discriminatedUnion("type", [
+  typeMessageEventSchema,
+  typePingEventSchema,
+  typeSuccessEventSchema,
+  typeErrorEventSchema,
+]);
+
+export type TypeMessageEvent = z.infer<typeof typeMessageEventSchema>;
+export type TypePingEvent = z.infer<typeof typePingEventSchema>;
+export type TypeSuccessEvent = z.infer<typeof typeSuccessEventSchema>;
+export type TypeErrorEvent = z.infer<typeof typeErrorEventSchema>;
+export type TypeInboundEvent = z.infer<typeof typeInboundEventSchema>;
+
+// ---------------------------------------------------------------------------
+// Outbound: Plugin -> Type Server
+// ---------------------------------------------------------------------------
+
+export interface PongMessage {
+  type: "pong";
+}
+
+export interface SendMessage {
+  type: "send";
+  channelId: string;
+  content: string;
+  parentMessageId?: string;
+}
+
+export interface RespondMessage {
+  type: "respond";
+  messageId: string;
+  content: string;
+}
+
+export interface StreamStartMessage {
+  type: "stream_start";
+  messageId: string;
+}
+
+export interface StreamEventMessage {
+  type: "stream_event";
+  messageId: string;
+  event: {
+    kind: string;
+    [key: string]: unknown;
+  };
+}
+
+export interface StreamFinishMessage {
+  type: "stream_finish";
+  messageId: string;
+}
+
+export type TypeOutboundMessage =
+  | PongMessage
+  | SendMessage
+  | RespondMessage
+  | StreamStartMessage
+  | StreamEventMessage
+  | StreamFinishMessage;

package/src/streamSession.ts

@@ -0,0 +1,181 @@
+/**
+ * Stream Session
+ *
+ * Manages the lifecycle of a single streaming response: lazy
+ * stream_start, ack gating, token/event buffering, and finish.
+ */
+
+import type { TypeOutboundHandler } from "./outbound.js";
+import type { ToolEventPayload } from "./toolEvents.js";
+
+const ACK_TIMEOUT_MS = 5000;
+
+export class StreamSession {
+  readonly #outbound: TypeOutboundHandler;
+  readonly #messageId: string;
+
+  #failed = false;
+  #started = false;
+  #ready = false;
+  #lastSentLength = 0;
+
+  #pendingTokens: string[] = [];
+  #pendingToolEvents: ToolEventPayload[] = [];
+  #pendingAck: { resolve: () => void; reject: (err: Error) => void } | null =
+    null;
+  #ackTimeoutId: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(outbound: TypeOutboundHandler, messageId: string) {
+    this.#outbound = outbound;
+    this.#messageId = messageId;
+  }
+
+  get isFailed(): boolean {
+    return this.#failed;
+  }
+
+  get isStarted(): boolean {
+    return this.#started;
+  }
+
+  /**
+   * Lazily send stream_start if not already started.
+   * Sets up the ack promise with a timeout. Call onAck() / onAckError()
+   * from the server response handler to resolve/reject.
+   */
+  ensureStarted(): void {
+    if (this.#started || this.#failed) return;
+
+    const sent = this.#outbound.startStream(this.#messageId);
+    if (!sent) {
+      console.error("[type] startStream send failed (connection not open)");
+      this.#failed = true;
+      return;
+    }
+    this.#started = true;
+
+    this.#pendingAck = {
+      resolve: () => {
+        this.#clearAckTimeout();
+        this.#ready = true;
+        this.#flushBuffers();
+      },
+      reject: (err: Error) => {
+        this.#clearAckTimeout();
+        console.error(`[type] stream_start rejected: ${err.message}`);
+        this.#failed = true;
+        this.#pendingTokens.length = 0;
+        this.#pendingToolEvents.length = 0;
+      },
+    };
+
+    this.#ackTimeoutId = setTimeout(() => {
+      this.#ackTimeoutId = null;
+      if (this.#pendingAck) {
+        this.#pendingAck.reject(new Error("stream_start ack timeout"));
+        this.#pendingAck = null;
+      }
+    }, ACK_TIMEOUT_MS);
+  }
+
+  /**
+   * Called by the server response handler when stream_start is acknowledged.
+   */
+  onAck(): void {
+    if (this.#pendingAck) {
+      this.#pendingAck.resolve();
+      this.#pendingAck = null;
+    }
+  }
+
+  /**
+   * Called by the server response handler when stream_start fails.
+   */
+  onAckError(error: Error): void {
+    if (this.#pendingAck) {
+      this.#pendingAck.reject(error);
+      this.#pendingAck = null;
+    }
+  }
+
+  /**
+   * Send a text token delta. Computes the delta from accumulated text,
+   * buffering if the stream_start ack hasn't arrived yet.
+   */
+  sendToken(fullText: string): void {
+    if (this.#failed) return;
+
+    const delta = fullText.slice(this.#lastSentLength);
+    if (delta.length === 0) return;
+    this.#lastSentLength = fullText.length;
+
+    this.ensureStarted();
+    if (this.#failed) return;
+
+    if (this.#ready) {
+      const sent = this.#outbound.streamToken(this.#messageId, delta);
+      if (!sent) {
+        console.error("[type] streamToken send failed (connection not open)");
+        this.#failed = true;
+      }
+    } else {
+      this.#pendingTokens.push(delta);
+    }
+  }
+
+  /**
+   * Send a tool event (tool-call, tool-result, etc.), buffering if needed.
+   */
+  sendToolEvent(event: ToolEventPayload): void {
+    if (this.#failed) return;
+
+    this.ensureStarted();
+    if (this.#failed) return;
+
+    if (this.#ready) {
+      this.#outbound.streamEvent(this.#messageId, event);
+    } else {
+      this.#pendingToolEvents.push(event);
+    }
+  }
+
+  /**
+   * Finalize the stream. Call after dispatch completes (success or error).
+   */
+  finish(): void {
+    if (!this.#started) return;
+    const finished = this.#outbound.finishStream(this.#messageId);
+    if (!finished) {
+      console.error(
+        "[type] finishStream send failed (connection not open), stream will idle-timeout on server",
+      );
+    }
+  }
+
+  #clearAckTimeout(): void {
+    if (this.#ackTimeoutId) {
+      clearTimeout(this.#ackTimeoutId);
+      this.#ackTimeoutId = null;
+    }
+  }
+
+  #flushBuffers(): void {
+    // Flush tool events first (they came before text)
+    for (const evt of this.#pendingToolEvents) {
+      if (this.#failed) break;
+      this.#outbound.streamEvent(this.#messageId, evt);
+    }
+    this.#pendingToolEvents.length = 0;
+
+    // Then flush text tokens
+    for (const text of this.#pendingTokens) {
+      if (this.#failed) break;
+      const sent = this.#outbound.streamToken(this.#messageId, text);
+      if (!sent) {
+        console.error("[type] streamToken send failed (connection not open)");
+        this.#failed = true;
+      }
+    }
+    this.#pendingTokens.length = 0;
+  }
+}

package/src/toolEvents.ts

@@ -0,0 +1,63 @@
+/**
+ * Tool Event Parsing
+ *
+ * Parses OpenClaw's formatted tool output text into structured
+ * tool-call and tool-result stream events for Type's UI.
+ */
+
+export interface ToolEventPayload {
+  kind: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Parse formatted tool text into a tool name and output.
+ *
+ * OpenClaw formats tool output like:
+ *   "📚 Read: /path/to/file"
+ *   "🧪 Exec: command here\noutput..."
+ *
+ * Strips leading emoji, splits on first colon.
+ */
+export function parseToolText(text: string): {
+  toolName: string;
+  toolOutput: string;
+} {
+  const trimmed = text.trim();
+  // Strip leading emoji (unicode emoji + variation selectors + ZWJ)
+  const stripped = trimmed.replace(/^(?:\p{Emoji}|\uFE0F|\u200D)+\s*/u, "");
+  const colonIdx = stripped.indexOf(":");
+  if (colonIdx > 0) {
+    return {
+      toolName: stripped.slice(0, colonIdx).trim(),
+      toolOutput: stripped.slice(colonIdx + 1).trim(),
+    };
+  }
+  return { toolName: "tool", toolOutput: stripped };
+}
+
+/**
+ * Create a tool-call + tool-result event pair from formatted tool text.
+ * Returns a 2-element array: [tool-call, tool-result].
+ */
+export function createToolEvents(
+  text: string,
+): [ToolEventPayload, ToolEventPayload] {
+  const { toolName, toolOutput } = parseToolText(text);
+  const toolCallId = `tool_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+  return [
+    {
+      kind: "tool-call",
+      toolCallId,
+      toolName,
+      input: toolOutput ? { command: toolOutput.split("\n")[0] } : {},
+    },
+    {
+      kind: "tool-result",
+      toolCallId,
+      toolName,
+      outcomes: [{ kind: "text", toolName, text: toolOutput }],
+    },
+  ];
+}