- Exa: report malformed search API JSON with a provider-owned error instead of leaking raw parser failures.

- Memory host SDK: report malformed remote JSON with caller-scoped errors for POST and batch file upload responses instead of leaking raw parser failures.

- Media providers: report malformed operation-poll and audio-transcription JSON with provider-owned errors instead of leaking raw parser failures.

- MiniMax, Gemini, Kimi, and Ollama web search: report malformed API JSON with provider-owned errors instead of leaking raw parser failures.

- Twilio voice-call: report malformed successful API JSON responses with provider-owned errors instead of leaking raw parser failures.

- Voice-call provider APIs: report malformed successful guarded JSON responses with provider-prefixed errors instead of leaking raw parser failures.

- Realtime transcription: report malformed provider websocket JSON frames with owned parser errors instead of leaking raw `SyntaxError` objects.

import {

createProviderHttpError,

formatProviderHttpErrorMessage,

readProviderJsonResponse,

} from "openclaw/plugin-sdk/provider-http";

import {

buildSearchCacheKey,

throw new Error(error.message.replace(/key=[^&\s]+/giu, "key=***"));

}

let data: GeminiGroundingResponse;

try {

data = (await res.json()) as GeminiGroundingResponse;

} catch (error) {

const safeError = String(error).replace(/key=[^&\s]+/giu, "key=***");

throw new Error(`Gemini API returned invalid JSON: ${safeError}`, { cause: error });

}

const data = await readProviderJsonResponse<GeminiGroundingResponse>(res, "Gemini API error");

if (data.error) {

const rawMessage = data.error.message || data.error.status || "unknown";

);

});

it("reports malformed Gemini API JSON with a stable provider error", async () => {

vi.stubGlobal(

"fetch",

withFetchPreconnect(vi.fn(() => Promise.resolve(new Response("{ nope")))),

);

const provider = createGeminiWebSearchProvider();

const tool = provider.createTool({

config: {

plugins: {

entries: {

google: {

config: {

webSearch: {

apiKey: "AIza-plugin-test",

},

},

},

},

},

},

searchConfig: { provider: "gemini" },

});

await expect(tool?.execute({ query: "OpenClaw docs" })).rejects.toThrow(

"Gemini API error: malformed JSON response",

);

});

it("passes provider execution abort signals into the Gemini fetch", async () => {

const mockFetch = installGeminiFetch();

const controller = new AbortController();

import {

createProviderHttpError,

formatProviderHttpErrorMessage,

readProviderJsonResponse,

} from "openclaw/plugin-sdk/provider-http";

import {

DEFAULT_SEARCH_COUNT,

throw await createProviderHttpError(res, "MiniMax Search API error");

}

const data = (await res.json()) as MiniMaxSearchResponse;

const data = await readProviderJsonResponse<MiniMaxSearchResponse>(

res,

"MiniMax Search API error",

);

if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {

throw new Error(

resolveMiniMaxApiKey,

resolveMiniMaxEndpoint,

resolveMiniMaxRegion,

readMiniMaxSearchJsonResponse: readProviderJsonResponse<MiniMaxSearchResponse>,

} as const;

resolveMiniMaxApiKey,

resolveMiniMaxEndpoint,

resolveMiniMaxRegion,

readMiniMaxSearchJsonResponse,

} = minimaxWebSearchTesting;

function restoreEnvValue(key: string, value: string | undefined) {

expect(MINIMAX_SEARCH_ENDPOINT_CN).toBe("https://api.minimaxi.com/v1/coding_plan/search");

});

});

it("reports malformed Search API JSON with a stable provider error", async () => {

await expect(

readMiniMaxSearchJsonResponse(new Response("{ nope"), "MiniMax Search API error"),

).rejects.toThrow("MiniMax Search API error: malformed JSON response");

});

});

import { createProviderHttpError } from "openclaw/plugin-sdk/provider-http";

import {

createProviderHttpError,

readProviderJsonResponse,

} from "openclaw/plugin-sdk/provider-http";

import type { OpenClawConfig } from "openclaw/plugin-sdk/provider-onboard";

import {

buildSearchCacheKey,

throw await createProviderHttpError(res, "Kimi API error");

}

const data = (await res.json()) as KimiSearchResponse;

const data = await readProviderJsonResponse<KimiSearchResponse>(res, "Kimi API error");

if (hasKimiSearchResults(data)) {

hasGroundingEvidence = true;

}

});

});

it("reports malformed Kimi API JSON with a stable provider error", async () => {

const fetchMock = vi.fn().mockResolvedValue(new Response("{ nope"));

vi.stubGlobal("fetch", fetchMock);

await withEnvAsync({ KIMI_API_KEY: "kimi-test-key" }, async () => {

await expect(executeKimiSearch("kimi malformed response")).rejects.toThrow(

"Kimi API error: malformed JSON response",

);

});

});

it("accepts final responses backed by Kimi web search tool replay", async () => {

const toolArguments = JSON.stringify({

query: "OpenClaw GitHub repository",

);

});

it("reports malformed Ollama web search JSON with a stable provider error", async () => {

fetchWithSsrFGuardMock.mockResolvedValueOnce({

response: new Response("{ nope", { status: 200 }),

release: vi.fn(async () => {}),

});

await expect(

runOllamaWebSearch({

config: createOllamaConfig(),

query: "openclaw",

}),

).rejects.toThrow("Ollama web search returned malformed JSON");

});

it("warns when Ollama is not reachable during setup without cancelling", async () => {

fetchWithSsrFGuardMock.mockRejectedValueOnce(new Error("connect failed"));

apiKey?: string;

};

async function readOllamaWebSearchResponse(response: Response): Promise<OllamaWebSearchResponse> {

try {

return (await response.json()) as OllamaWebSearchResponse;

} catch (cause) {

throw new Error("Ollama web search returned malformed JSON", { cause });

}

}

function isOllamaCloudBaseUrl(baseUrl: string): boolean {

try {

const parsed = new URL(baseUrl);

}

throw new Error(message);

}

payload = (await response.json()) as OllamaWebSearchResponse;

payload = await readOllamaWebSearchResponse(response);

break;

} catch (error) {

if (error instanceof Error) {

resolveOllamaWebSearchApiKey,

resolveOllamaWebSearchBaseUrl,

isOllamaCloudBaseUrl,

readOllamaWebSearchResponse,

warnOllamaWebSearchPrereqs,

};