fix(providers): harden malformed success responses

vincentkoc · vincentkoc · commit ba8a6499f02f · 2026-05-16T03:57:25.000+08:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -17,6 +17,7 @@ Docs: https://docs.openclaw.ai
 - Plugins: reject malformed `package.json` `openclaw.extensions` metadata during install, discovery, and post-update payload smoke instead of silently dropping invalid entries.
 - Media/files: sniff `input_file` bytes before trusting declared MIME headers, rejecting spoofed image or zip payloads before they become agent-visible text.
 - Config persistence: ignore malformed array/scalar auth profile, cron job state, and session store entries instead of hydrating them into numeric profile ids, crashed cron rows, or invalid session records.
+- Providers: reject malformed successful Runway, BytePlus, and Ollama embedding responses with provider-owned errors instead of raw parser/type failures, silent bad vectors, or long bogus polling.
 - Hooks: raise bounded gateway lifecycle hook wait budgets to 5 seconds for shutdown and 10 seconds for pre-restart, giving short restart notification handlers time to finish before shutdown continues. (#82273) Thanks @bryanbaer.
 - Plugin releases: require external package compatibility metadata in the npm plugin publish plan, matching the ClawHub package contract before packages ship.
 - Agents/OpenAI-compatible: honor per-model `max_completion_tokens`/`max_tokens` params in embedded OpenAI-completions runs so high-token Kimi-style routes keep their configured completion cap. Fixes #82230. Thanks @albert-zen.
diff --git a/extensions/byteplus/video-generation-provider.test.ts b/extensions/byteplus/video-generation-provider.test.ts
@@ -144,4 +144,80 @@ describe("byteplus video generation provider", () => {
     expect(body.resolution).toBe("480p");
     expect(body.camera_fixed).toBe(false);
   });
+
+  it("reports malformed create JSON with a provider-owned error", async () => {
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => {
+          throw new SyntaxError("bad json");
+        },
+      },
+      release,
+    });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "byteplus",
+        model: "seedance-1-0-lite-t2v-250428",
+        prompt: "bad create response",
+        cfg: {},
+      }),
+    ).rejects.toThrow("BytePlus video generation failed: malformed JSON response");
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("rejects status responses missing a task status", async () => {
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({ id: "task_missing_status" }),
+      },
+      release: vi.fn(async () => {}),
+    });
+    fetchWithTimeoutMock.mockResolvedValueOnce({
+      json: async () => ({
+        id: "task_missing_status",
+        content: {
+          video_url: "https://example.com/byteplus.mp4",
+        },
+      }),
+    });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "byteplus",
+        model: "seedance-1-0-lite-t2v-250428",
+        prompt: "missing status",
+        cfg: {},
+      }),
+    ).rejects.toThrow("BytePlus video status response missing task status");
+  });
+
+  it("rejects malformed completed content", async () => {
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({ id: "task_malformed_content" }),
+      },
+      release: vi.fn(async () => {}),
+    });
+    fetchWithTimeoutMock.mockResolvedValueOnce({
+      json: async () => ({
+        id: "task_malformed_content",
+        status: "succeeded",
+        content: ["https://example.com/byteplus.mp4"],
+      }),
+    });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "byteplus",
+        model: "seedance-1-0-lite-t2v-250428",
+        prompt: "malformed content",
+        cfg: {},
+      }),
+    ).rejects.toThrow("BytePlus video generation completed with malformed content");
+  });
 });
diff --git a/extensions/byteplus/video-generation-provider.ts b/extensions/byteplus/video-generation-provider.ts
@@ -27,27 +27,74 @@ const POLL_INTERVAL_MS = 5_000;
 const MAX_POLL_ATTEMPTS = 120;
 
 type BytePlusTaskCreateResponse = {
-  id?: string;
+  id?: unknown;
 };
 
 type BytePlusTaskResponse = {
-  id?: string;
-  model?: string;
-  status?: "running" | "failed" | "queued" | "succeeded" | "cancelled";
-  error?: {
-    code?: string;
-    message?: string;
-  };
-  content?: {
-    video_url?: string;
-    last_frame_url?: string;
-    file_url?: string;
-  };
-  duration?: number;
-  ratio?: string;
-  resolution?: string;
+  id?: unknown;
+  model?: unknown;
+  status?: unknown;
+  error?: unknown;
+  content?: unknown;
+  duration?: unknown;
+  ratio?: unknown;
+  resolution?: unknown;
 };
 
+type BytePlusTaskStatus = "running" | "failed" | "queued" | "succeeded" | "cancelled";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function readBytePlusJsonResponse<T>(
+  response: Pick<Response, "json">,
+  label: string,
+): Promise<T> {
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch (cause) {
+    throw new Error(`${label}: malformed JSON response`, { cause });
+  }
+  if (!isRecord(payload)) {
+    throw new Error(`${label}: malformed JSON response`);
+  }
+  return payload as T;
+}
+
+function readBytePlusTaskStatus(payload: BytePlusTaskResponse): BytePlusTaskStatus {
+  const status = normalizeOptionalString(payload.status);
+  switch (status) {
+    case "running":
+    case "failed":
+    case "queued":
+    case "succeeded":
+    case "cancelled":
+      return status;
+    case undefined:
+      throw new Error("BytePlus video status response missing task status");
+    default:
+      throw new Error(`BytePlus video status response returned unknown task status: ${status}`);
+  }
+}
+
+function readBytePlusErrorMessage(error: unknown): string | undefined {
+  return isRecord(error) ? normalizeOptionalString(error.message) : undefined;
+}
+
+function readBytePlusVideoUrl(payload: BytePlusTaskResponse): string {
+  const content = payload.content;
+  if (content !== undefined && !isRecord(content)) {
+    throw new Error("BytePlus video generation completed with malformed content");
+  }
+  const videoUrl = normalizeOptionalString(content?.video_url);
+  if (!videoUrl) {
+    throw new Error("BytePlus video generation completed without a video URL");
+  }
+  return videoUrl;
+}
+
 function resolveBytePlusVideoBaseUrl(req: VideoGenerationRequest): string {
   return (
     normalizeOptionalString(req.cfg?.models?.providers?.byteplus?.baseUrl) ?? BYTEPLUS_BASE_URL
@@ -100,14 +147,17 @@ async function pollBytePlusTask(params: {
       provider: "byteplus",
       requestFailedMessage: "BytePlus video status request failed",
     });
-    const payload = (await response.json()) as BytePlusTaskResponse;
-    switch (normalizeOptionalString(payload.status)) {
+    const payload = await readBytePlusJsonResponse<BytePlusTaskResponse>(
+      response,
+      "BytePlus video status request failed",
+    );
+    switch (readBytePlusTaskStatus(payload)) {
       case "succeeded":
         return payload;
       case "failed":
       case "cancelled":
         throw new Error(
-          normalizeOptionalString(payload.error?.message) || "BytePlus video generation failed",
+          readBytePlusErrorMessage(payload.error) || "BytePlus video generation failed",
         );
       case "queued":
       case "running":
@@ -292,7 +342,10 @@ export function buildBytePlusVideoGenerationProvider(): VideoGenerationProvider
       });
       try {
         await assertOkOrThrowHttpError(response, "BytePlus video generation failed");
-        const submitted = (await response.json()) as BytePlusTaskCreateResponse;
+        const submitted = await readBytePlusJsonResponse<BytePlusTaskCreateResponse>(
+          response,
+          "BytePlus video generation failed",
+        );
         const taskId = normalizeOptionalString(submitted.id);
         if (!taskId) {
           throw new Error("BytePlus video generation response missing task id");
@@ -307,10 +360,7 @@ export function buildBytePlusVideoGenerationProvider(): VideoGenerationProvider
           baseUrl,
           fetchFn,
         });
-        const videoUrl = normalizeOptionalString(completed.content?.video_url);
-        if (!videoUrl) {
-          throw new Error("BytePlus video generation completed without a video URL");
-        }
+        const videoUrl = readBytePlusVideoUrl(completed);
         const video = await downloadBytePlusVideo({
           url: videoUrl,
           timeoutMs: createProviderOperationTimeoutResolver({
@@ -321,14 +371,14 @@ export function buildBytePlusVideoGenerationProvider(): VideoGenerationProvider
         });
         return {
           videos: [video],
-          model: completed.model ?? resolvedModel,
+          model: normalizeOptionalString(completed.model) ?? resolvedModel,
           metadata: {
             taskId,
-            status: completed.status,
+            status: normalizeOptionalString(completed.status),
             videoUrl,
-            ratio: completed.ratio,
-            resolution: completed.resolution,
-            duration: completed.duration,
+            ratio: normalizeOptionalString(completed.ratio),
+            resolution: normalizeOptionalString(completed.resolution),
+            duration: typeof completed.duration === "number" ? completed.duration : undefined,
           },
         };
       } finally {
diff --git a/extensions/ollama/src/embedding-provider.test.ts b/extensions/ollama/src/embedding-provider.test.ts
@@ -251,6 +251,56 @@ describe("ollama embedding provider", () => {
     expect(inputs).toEqual([["a", "bb", "ccc"]]);
   });
 
+  it("reports malformed embed JSON with a provider-owned error", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(
+        async () =>
+          new Response("{not json", {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          }),
+      ),
+    );
+
+    const { provider } = await createOllamaEmbeddingProvider({
+      config: {} as OpenClawConfig,
+      provider: "ollama",
+      model: "nomic-embed-text",
+      fallback: "none",
+      remote: { baseUrl: "http://127.0.0.1:11434" },
+    });
+
+    await expect(provider.embedQuery("hello")).rejects.toThrow(
+      "Ollama embed response returned malformed JSON",
+    );
+  });
+
+  it("rejects non-number embedding values instead of zeroing them", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(
+        async () =>
+          new Response(JSON.stringify({ embeddings: [["0.1", 0.2]] }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+          }),
+      ),
+    );
+
+    const { provider } = await createOllamaEmbeddingProvider({
+      config: {} as OpenClawConfig,
+      provider: "ollama",
+      model: "nomic-embed-text",
+      fallback: "none",
+      remote: { baseUrl: "http://127.0.0.1:11434" },
+    });
+
+    await expect(provider.embedQuery("hello")).rejects.toThrow(
+      "Ollama embed response contains a non-number embedding value",
+    );
+  });
+
   it("uses a retrieval query prefix for qwen3 embedding queries", async () => {
     const fetchMock = mockEmbeddingFetch([1, 0]);
 
diff --git a/extensions/ollama/src/embedding-provider.ts b/extensions/ollama/src/embedding-provider.ts
@@ -73,8 +73,13 @@ const QUERY_INSTRUCTION_TEMPLATES = [
   },
 ] as const;
 
-function sanitizeAndNormalizeEmbedding(vec: number[]): number[] {
-  const sanitized = vec.map((value) => (Number.isFinite(value) ? value : 0));
+function sanitizeAndNormalizeEmbedding(vec: unknown[]): number[] {
+  const sanitized = vec.map((value) => {
+    if (typeof value !== "number") {
+      throw new Error("Ollama embed response contains a non-number embedding value");
+    }
+    return Number.isFinite(value) ? value : 0;
+  });
   const magnitude = Math.sqrt(sanitized.reduce((sum, value) => sum + value * value, 0));
   if (magnitude < 1e-10) {
     return sanitized;
@@ -101,6 +106,21 @@ async function withRemoteHttpResponse<T>(params: {
   }
 }
 
+async function readOllamaEmbeddingJsonResponse(
+  response: Pick<Response, "json">,
+): Promise<{ embeddings?: unknown }> {
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch (cause) {
+    throw new Error("Ollama embed response returned malformed JSON", { cause });
+  }
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+    throw new Error("Ollama embed response returned a non-object JSON payload");
+  }
+  return payload as { embeddings?: unknown };
+}
+
 function normalizeEmbeddingModel(model: string, providerId?: string): string {
   const trimmed = model.trim();
   if (!trimmed) {
@@ -315,7 +335,7 @@ export async function createOllamaEmbeddingProvider(
         if (!response.ok) {
           throw new Error(`Ollama embed HTTP ${response.status}: ${await response.text()}`);
         }
-        return (await response.json()) as { embeddings?: unknown };
+        return await readOllamaEmbeddingJsonResponse(response);
       },
     });
     if (!Array.isArray(json.embeddings)) {
diff --git a/extensions/runway/video-generation-provider.test.ts b/extensions/runway/video-generation-provider.test.ts
diff --git a/extensions/runway/video-generation-provider.ts b/extensions/runway/video-generation-provider.ts
