b758a1c5503c08325113e0d6c9f1ac2db5a5fd9992a3902706ebe0f0dbbc1213 plugin-sdk-api-baseline.json

2c9d0a00e526dcd47d131261b8ceddd8e59faa8530b129d108a3721a4cbcbea7 plugin-sdk-api-baseline.jsonl

b86e6785acbd0f8f0f012691ce823c2e8d52bfd2507c2258408503162abb9adf plugin-sdk-api-baseline.json

e10acbed6c7c1b21700e358411c73877bdc0cb59ce102bafe680e210a2ac741b plugin-sdk-api-baseline.jsonl

import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";

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

import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";

import type {

SpeechDirectiveTokenParseContext,

"xi-api-key": params.apiKey,

},

});

if (!res.ok) {

throw new Error(`ElevenLabs voices API error (${res.status})`);

}

await assertOkOrThrowProviderError(res, "ElevenLabs voices API error");

const json = (await res.json()) as {

voices?: Array<{

voice_id?: string;

import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";

import {

assertOkOrThrowHttpError,

assertOkOrThrowProviderError,

resolveProviderHttpRequestConfig,

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

import {

auditContext: "fal-image-download",

});

try {

if (!response.ok) {

const text = await response.text().catch(() => "");

throw new Error(

`fal image download failed (${response.status}): ${text || response.statusText}`,

);

}

await assertOkOrThrowProviderError(response, "fal image download failed");

const mimeType = response.headers.get("content-type")?.trim() || "image/png";

const arrayBuffer = await response.arrayBuffer();

return { buffer: Buffer.from(arrayBuffer), mimeType };

sanitizeAndNormalizeEmbedding,

withRemoteHttpResponse,

} from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";

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

import type { GeminiEmbeddingClient, GeminiTextEmbeddingRequest } from "./embedding-provider.js";

export type GeminiBatchRequest = {

},

onResponse: async (res) => {

if (!res.ok) {

const text = await res.text();

throw new Error(`gemini batch status failed: ${res.status} ${text}`);

throw await createProviderHttpError(res, "gemini batch status failed");

}

return (await res.json()) as GeminiBatchStatus;

},

},

onResponse: async (res) => {

if (!res.ok) {

const text = await res.text();

throw new Error(`gemini batch file content failed: ${res.status} ${text}`);

throw await createProviderHttpError(res, "gemini batch file content failed");

}

return await res.text();

},

requireApiKey,

resolveApiKeyForProvider,

} from "openclaw/plugin-sdk/provider-auth-runtime";

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

import type { SsrFPolicy } from "openclaw/plugin-sdk/ssrf-runtime";

import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";

},

onResponse: async (res) => {

if (!res.ok) {

const text = await res.text();

throw new Error(`gemini embeddings failed: ${res.status} ${text}`);

throw await createProviderHttpError(res, "gemini embeddings failed");

}

return (await res.json()) as {

embedding?: { values?: number[] };

import {

createProviderHttpError,

formatProviderHttpErrorMessage,

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

import {

buildSearchCacheKey,

buildUnsupportedSearchFilterResponse,

},

async (res) => {

if (!res.ok) {

const safeDetail = ((await res.text()) || res.statusText).replace(

/key=[^&\s]+/giu,

"key=***",

);

throw new Error(`Gemini API error (${res.status}): ${safeDetail}`);

const error = await createProviderHttpError(res, "Gemini API error");

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

}

let data: GeminiGroundingResponse;

if (data.error) {

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

throw new Error(

`Gemini API error (${data.error.code}): ${rawMessage.replace(/key=[^&\s]+/giu, "key=***")}`,

formatProviderHttpErrorMessage({

label: "Gemini API error",

status: data.error.code ?? 0,

detail: rawMessage.replace(/key=[^&\s]+/giu, "key=***"),

}),

);

}

type SimpleStreamOptions,

type ThinkingLevel,

} from "@mariozechner/pi-ai";

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

import {

buildGuardedModelFetch,

coerceTransportToolCallArguments,

signal: options?.signal,

});

if (!response.ok) {

const message = await response.text().catch(() => "");

throw new Error(`Google Generative AI API error (${response.status}): ${message}`);

throw await createProviderHttpError(response, "Google Generative AI API error");

}

stream.push({ type: "start", partial: output as never });

let currentBlockIndex = -1;

generateSecMsGecToken,

} from "node-edge-tts/dist/drm.js";

import { isVoiceCompatibleAudio } from "openclaw/plugin-sdk/media-runtime";

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

import {

captureHttpExchange,

isDebugProxyGlobalFetchPatchInstalled,

},

});

}

if (!response.ok) {

throw new Error(`Microsoft voices API error (${response.status})`);

}

await assertOkOrThrowProviderError(response, "Microsoft voices API error");

const voices = (await response.json()) as MicrosoftVoiceListEntry[];

return Array.isArray(voices)

? voices

import {

createProviderHttpError,

formatProviderHttpErrorMessage,

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

import {

DEFAULT_SEARCH_COUNT,

buildSearchCacheKey,

},

async (res) => {

if (!res.ok) {

const detail = await res.text();

throw new Error(`MiniMax Search API error (${res.status}): ${detail || res.statusText}`);

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

}

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

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

throw new Error(

`MiniMax Search API error (${data.base_resp.status_code}): ${data.base_resp.status_msg || "unknown error"}`,

formatProviderHttpErrorMessage({

label: "MiniMax Search API error",

status: data.base_resp.status_code,

detail: data.base_resp.status_msg || "unknown error",

}),

);

}

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

export const DEFAULT_MINIMAX_TTS_BASE_URL = "https://api.minimax.io";

export const MINIMAX_TTS_MODELS = ["speech-2.8-hd", "speech-01-240228"] as const;

signal: controller.signal,

});

if (!response.ok) {

const errBody = await response.text().catch(() => "");

throw new Error(`MiniMax TTS API error (${response.status})${errBody ? `: ${errBody}` : ""}`);

}

await assertOkOrThrowProviderError(response, "MiniMax TTS API error");

const body = (await response.json()) as { data?: { audio?: string } };

const hexAudio = body?.data?.audio;