: undefined

: undefined;

export type ResolveWebFetchDefinitionParams = {

type ResolveWebFetchDefinitionParams = {

config?: OpenClawConfig;

sandboxed?: boolean;

runtimeWebFetch?: RuntimeWebFetchMetadata;

};

/** Resolves whether web_fetch is enabled for the current config/sandbox. */

export function resolveWebFetchEnabled(params: {

function resolveWebFetchEnabled(params: {

fetch?: WebFetchConfig;

sandboxed?: boolean;

}): boolean {

});

}

/** Lists plugin-configured web_fetch providers. */

export function listConfiguredWebFetchProviders(params?: {

config?: OpenClawConfig;

}): PluginWebFetchProviderEntry[] {

return resolvePluginWebFetchProviders({

config: params?.config,

});

}

/** Resolves the configured or auto-detected web_fetch provider id. */

export function resolveWebFetchProviderId(params: {

function resolveWebFetchProviderId(params: {

fetch?: WebFetchConfig;

config?: OpenClawConfig;

providers?: PluginWebFetchProviderEntry[];

describe("web search runtime", () => {

let runWebSearch: typeof import("./runtime.js").runWebSearch;

let resolveWebSearchDefinition: typeof import("./runtime.js").resolveWebSearchDefinition;

let activateSecretsRuntimeSnapshot: typeof import("../secrets/runtime.js").activateSecretsRuntimeSnapshot;

let clearSecretsRuntimeSnapshot: typeof import("../secrets/runtime.js").clearSecretsRuntimeSnapshot;

let setRuntimeConfigSnapshot: typeof import("../config/config.js").setRuntimeConfigSnapshot;

const tempDirs: string[] = [];

beforeAll(async () => {

({ resolveWebSearchDefinition, runWebSearch } = await import("./runtime.js"));

({ runWebSearch } = await import("./runtime.js"));

({ activateSecretsRuntimeSnapshot, clearSecretsRuntimeSnapshot } =

await import("../secrets/runtime.js"));

({ setRuntimeConfigSnapshot } = await import("../config/config.js"));

).rejects.toThrow("web_search is disabled or no provider is available.");

});

it("does not resolve a keyless provider definition when no provider is configured", () => {

resolvePluginWebSearchProvidersMock.mockReturnValue([createDuckDuckGoSearchProvider()]);

const resolved = resolveWebSearchDefinition({

config: {},

});

expect(resolved).toBeNull();

});

it("uses a keyless provider when the user explicitly selects it", async () => {

resolveRuntimeWebSearchProvidersMock.mockReturnValue([createDuckDuckGoSearchProvider()]);

expect(createTool).not.toHaveBeenCalled();

});

it("ignores auto-detected keyless runtime metadata when resolving a provider definition", () => {

resolvePluginWebSearchProvidersMock.mockReturnValue([

createWebSearchTestProvider({

pluginId: "parallel",

id: "parallel-free",

credentialPath: "",

autoDetectOrder: 76,

requiresCredential: false,

}),

]);

const resolved = resolveWebSearchDefinition({

config: {},

runtimeWebSearch: {

providerSource: "auto-detect",

selectedProvider: "parallel-free",

diagnostics: [],

},

});

expect(resolved).toBeNull();

});

it("falls back to another provider when auto-selected search execution fails", async () => {

resolveRuntimeWebSearchProvidersMock.mockReturnValue([

createGoogleSearchProvider({

RuntimeWebSearchConfig as WebSearchConfig,

} from "./runtime-types.js";

// Runtime provider selection and execution for web_search. This keeps plugin,

// runtime, and explicit provider selections aligned before a tool executes.

export type {

ListWebSearchProvidersParams,

ResolveWebSearchDefinitionParams,

RunWebSearchParams,

RunWebSearchResult,

RuntimeWebSearchConfig,

RuntimeWebSearchProviderEntry,

RuntimeWebSearchToolDefinition,

} from "./runtime-types.js";

function resolveSearchConfig(cfg?: OpenClawConfig): WebSearchConfig {

return resolveWebProviderConfig(cfg, "search") as NonNullable<WebSearchConfig> | undefined;

}

}

/** Resolves whether web_search is enabled for the current config/sandbox. */

export function resolveWebSearchEnabled(params: {

function resolveWebSearchEnabled(params: {

search?: WebSearchConfig;

sandboxed?: boolean;

}): boolean {

}

/** Resolves the executable web_search provider tool definition. */

export function resolveWebSearchDefinition(

function resolveWebSearchDefinition(

options?: ResolveWebSearchDefinitionParams,

): { provider: PluginWebSearchProviderEntry; definition: WebSearchProviderToolDefinition } | null {

const { config, search, runtimeWebSearch } = resolveWebSearchRequestContext(options);

}

throw lastError instanceof Error ? lastError : new Error(String(lastError));

}

export const testing = {

resolveSearchConfig,

resolveSearchProvider: resolveWebSearchProviderId,

resolveWebSearchProviderId,

resolveWebSearchCandidates,

resolveExplicitWebSearchProviderId,

resolveExplicitWebSearchProviderPluginIds,

hasExplicitWebSearchSelection,

};

export { testing as __testing };