@newbase-clawchat/openclaw-clawchat 2026.5.4 → 2026.5.12-13

package/src/media-runtime.ts

@@ -1,16 +1,18 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
+import {
+  buildOutboundMediaLoadOptions,
+  type OutboundMediaAccess,
+  type OutboundMediaReadFile,
+} from "openclaw/plugin-sdk/media-runtime";
 import type { OpenclawClawlingApiClient } from "./api-client.ts";
 
 /**
- * Local structural superset of the SDK's media fragment narrow types.
+ * Local structural superset of the protocol media fragment narrow types.
  *
- * `@clawling/chat-sdk@^0.2.0` exports each narrow type
- * (`ImageFragment` / `FileFragment` / `AudioFragment` / `VideoFragment`)
- * with a literal `kind` that distinguishes them. Building the wide
- * shape locally avoids per-kind switch statements when constructing
- * outbound fragments; structural compatibility lets a single object
- * satisfy whichever narrow type matches its runtime `kind`. We cast
- * to `Fragment[]` only at the SDK boundary (outbound.ts).
+ * Each media fragment has a literal `kind` that distinguishes it. Building the
+ * wide shape locally avoids per-kind switch statements when constructing
+ * outbound fragments; structural compatibility lets a single object satisfy
+ * whichever narrow type matches its runtime `kind`.
  */
 export interface MediaItem {
   kind: "image" | "file" | "audio" | "video";
@@ -42,8 +44,12 @@ export interface UploadOutboundCtx {
   runtime: PluginRuntime;
   log?: LogSink;
   maxBytes?: number;
+  /** Host-authorized outbound media access from OpenClaw message delivery. */
+  mediaAccess?: OutboundMediaAccess;
   /** Allowed local roots for path-based uploads. Empty/undefined = use loadWebMedia defaults. */
-  mediaLocalRoots?: readonly string[];
+  mediaLocalRoots?: readonly string[] | "any";
+  /** Host-provided read bridge for sandbox/allowed local media paths. */
+  mediaReadFile?: OutboundMediaReadFile;
 }
 
 export function inferMediaKindFromMime(mime: string | undefined): MediaItem["kind"] {
@@ -114,24 +120,27 @@ export async function uploadOutboundMedia(
   const out: ClawlingMediaFragment[] = [];
   for (const url of urls) {
     try {
-      const loaded = await ctx.runtime.media.loadWebMedia(url, {
-        maxBytes,
-        ...(ctx.mediaLocalRoots && ctx.mediaLocalRoots.length > 0
-          ? { localRoots: ctx.mediaLocalRoots }
-          : {}),
-      });
+      const loaded = await ctx.runtime.media.loadWebMedia(
+        url,
+        buildOutboundMediaLoadOptions({
+          maxBytes,
+          ...(ctx.mediaAccess ? { mediaAccess: ctx.mediaAccess } : {}),
+          ...(ctx.mediaLocalRoots ? { mediaLocalRoots: ctx.mediaLocalRoots } : {}),
+          ...(ctx.mediaReadFile ? { mediaReadFile: ctx.mediaReadFile } : {}),
+        }),
+      );
       const uploaded = await ctx.apiClient.uploadMedia({
         buffer: loaded.buffer,
         filename: loaded.fileName ?? "upload.bin",
         mime: loaded.contentType,
       });
       const fragment: ClawlingMediaFragment = {
-        kind: inferMediaKindFromMime(uploaded.mime),
+        kind: uploaded.kind,
         url: uploaded.url,
+        name: uploaded.name,
         mime: uploaded.mime,
         size: uploaded.size,
       };
-      if (loaded.fileName) fragment.name = loaded.fileName;
       out.push(fragment);
     } catch (err) {
       ctx.log?.error?.(

package/src/message-mapper.test.ts

@@ -1,4 +1,4 @@
-import type { Fragment } from "@newbase-clawchat/sdk";
+import type { Fragment } from "./protocol-types.ts";
 import { describe, expect, it } from "vitest";
 import { extractMediaFragments, fragmentsToText, textToFragments } from "./message-mapper.ts";
 
@@ -119,7 +119,7 @@ describe("openclaw-clawchat message-mapper", () => {
   });
 
   it("extractMediaFragments skips media fragments without url", () => {
-    // Note: SDK 0.2.0 requires `url` on image fragments — using a partial
+    // Note: the protocol type requires `url` on image fragments — using a partial
     // object here exercises the runtime guard. Casting here is intentional
     // (we want to verify defensive handling of malformed input).
     const fragments: Fragment[] = [

package/src/message-mapper.ts

@@ -1,4 +1,4 @@
-import type { Fragment } from "@newbase-clawchat/sdk";
+import type { Fragment } from "./protocol-types.ts";
 import type { MediaItem } from "./media-runtime.ts";
 
 interface FlattenOptions {
@@ -61,7 +61,7 @@ export function textToFragments(text: string): Fragment[] {
 /**
  * Extract media fragments from a body (image/file/audio/video). Skips
  * entries missing `url`. Preserves all optional metadata fields the
- * SDK passes through (mime/size/width/height/duration/name).
+ * protocol carries through (mime/size/width/height/duration/name).
  */
 export function extractMediaFragments(fragments: Fragment[]): MediaItem[] {
   const out: MediaItem[] = [];

package/src/mock-transport.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from "vitest";
+import { MockTransport } from "./mock-transport.ts";
+
+describe("MockTransport", () => {
+  it("opens, records sent frames, emits inbound frames, and closes", async () => {
+    const transport = new MockTransport();
+    const onOpen = vi.fn();
+    const onMessage = vi.fn();
+    const onClose = vi.fn();
+    const onError = vi.fn();
+
+    await transport.connect("ws://test", { onOpen, onMessage, onClose, onError });
+    expect(transport.state).toBe("open");
+    expect(onOpen).toHaveBeenCalledTimes(1);
+
+    transport.send("frame-1");
+    expect(transport.sent).toEqual(["frame-1"]);
+
+    transport.emitInbound("frame-2");
+    expect(onMessage).toHaveBeenCalledWith("frame-2");
+
+    const buffer = Buffer.from("frame-3");
+    transport.emitInbound(buffer);
+    expect(onMessage).toHaveBeenCalledWith(buffer);
+
+    const err = new Error("boom");
+    transport.emitError(err);
+    expect(onError).toHaveBeenCalledWith(err);
+
+    transport.close(1000, "done");
+    expect(transport.state).toBe("closed");
+    expect(onClose).toHaveBeenCalledWith(1000, "done");
+    expect(onError).toHaveBeenCalledTimes(1);
+  });
+});

package/src/mock-transport.ts

@@ -0,0 +1,38 @@
+import type { Transport, TransportEvents, TransportState } from "./protocol-types.ts";
+
+export class MockTransport implements Transport {
+  private handlers?: TransportEvents;
+  private currentState: TransportState = "closed";
+  readonly sent: string[] = [];
+
+  get state(): TransportState {
+    return this.currentState;
+  }
+
+  async connect(_url: string, handlers: TransportEvents): Promise<void> {
+    this.handlers = handlers;
+    this.currentState = "open";
+    handlers.onOpen();
+  }
+
+  send(data: string): void {
+    if (this.currentState !== "open") {
+      throw new Error("transport is not open");
+    }
+    this.sent.push(data);
+  }
+
+  close(code = 1000, reason = "client close"): void {
+    if (this.currentState === "closed") return;
+    this.currentState = "closed";
+    this.handlers?.onClose(code, reason);
+  }
+
+  emitInbound(data: string | Buffer): void {
+    this.handlers?.onMessage(data);
+  }
+
+  emitError(err: Error): void {
+    this.handlers?.onError(err);
+  }
+}