// Live-sweeps discovered model profiles with optional provider/model filters and probes.

import { writeSync } from "node:fs";

import { normalizeProviderId } from "@openclaw/model-catalog-core/provider-id";

import { type Api, completeSimple, type Model } from "openclaw/plugin-sdk/llm";

function parseExplicitLiveModelRefs(

filter: Set<string> | null,

): Array<{ provider: string; id: string }> {

// Explicit refs use provider/model syntax; bare provider filters are handled elsewhere.

if (!filter) {

return [];

}

explicitRefs: readonly { provider: string; id: string }[];

priorityRefs?: readonly { provider: string; id: string }[];

}): string[] | undefined {

// Narrow startup discovery to providers that can affect the requested live target set.

const providers = new Set<string>();

for (const provider of params.providerFilter ?? []) {

const normalized = normalizeProviderId(provider);

// Live smoke test for Moonshot OpenAI-compatible completions behavior.

import { completeSimple, type Model } from "openclaw/plugin-sdk/llm";

import { describe, expect, it } from "vitest";

import {

// Verifies OpenAI-compatible payloads contain at least one sendable conversation turn.

import { describe, expect, it } from "vitest";

import { hasOpenAICompatibleConversationTurn } from "./openai-compatible-conversation-turn.js";

});

it("accepts assistant tool calls even when assistant content is empty", () => {

// Tool-call turns are sendable even when visible assistant text is absent.

expect(

hasOpenAICompatibleConversationTurn([

{

// Verifies OpenAI-compatible endpoint defaults for streaming usage and reasoning payloads.

import { describe, expect, it } from "vitest";

import {

detectOpenAICompletionsCompat,

it.each(["vllm", "sglang", "lmstudio"])(

"enables streaming usage compat for manifest-declared local provider %s",

(provider) => {

// Manifest capability, not provider id alone, enables local streaming usage compat.

expect(

resolveOpenAICompletionsCompatDefaults({

provider,

describe("xiaomi compat detection", () => {

it("sets thinkingFormat to deepseek for xiaomi-native endpoint", () => {

// Xiaomi's OpenAI-compatible route uses DeepSeek-style reasoning payloads.

expect(

resolveOpenAICompletionsCompatDefaults({

provider: "xiaomi",

// Live checks for OpenAI reasoning compatibility and repaired tool replay payloads.

import type { AgentMessage } from "openclaw/plugin-sdk/agent-core";

import { SessionManager } from "openclaw/plugin-sdk/agent-sessions";

import type { Model } from "openclaw/plugin-sdk/llm";

apiKey: string;

message: string;

}): Promise<{ text: string; errorMessage?: string }> {

// Some reasoning targets spend the first tiny budget without visible text.

const runOnce = async (maxTokens: number) => {

const response = await completeSimpleWithTimeout(

params.model,

}

function isKnownLiveBlocker(errorMessage: string): boolean {

// Live lane should skip account/usage blockers rather than fail unrelated compat checks.

return (

/not supported when using codex with a chatgpt account/i.test(errorMessage) ||

/hit your chatgpt usage limit/i.test(errorMessage)

);

}

function resolveTargetModelRef(): { provider: string; modelId: string } {

// Keep env override parsing strict so live runs never silently target the wrong model.

const [provider, ...rest] = TARGET_MODEL_REF.split("/");

const modelId = rest.join("/").trim();

if (!provider?.trim() || !modelId) {

// Verifies model-specific OpenAI reasoning-effort normalization and disablement.

import { describe, expect, it } from "vitest";

import {

resolveOpenAIReasoningEffortForModel,

});

it("allows provider-native compat values when explicitly declared", () => {

// Some OpenAI-compatible providers expose their own reasoning effort labels.

const model = {

provider: "groq",

id: "qwen/qwen3-32b",