import { expect, vi } from "vitest";

import type { ProviderRuntimeModel } from "../plugins/provider-runtime-model.types.js";

import type { AgentMessage } from "./runtime/index.js";

import type { SessionManager } from "./sessions/index.js";

import type { TranscriptPolicy } from "./transcript-policy.js";

sessionManager: SessionManager;

sessionId: string;

modelId?: string;

model?: ProviderRuntimeModel;

policy?: TranscriptPolicy;

preserveLatestAssistantThinking?: boolean;

}) => Promise<AgentMessage[]>;

}

function shouldTrustReasoningContentReplayMetadata(model: OpenAIModeModel): boolean {

if (model.reasoning !== true || isGemma4ModelId(model.id)) {

if (!model.reasoning || isGemma4ModelId(model.id)) {

return false;

}

const provider = model.provider.trim().toLowerCase();

expect(options.cleanupBundleMcpOnRunEnd).toBe(true);

});

it("marks the run lane-local so internal-helper failures do not poison shared profile health (#71709)", async () => {

await generateSlugViaLLM({

sessionContent: "hello",

cfg: {} as OpenClawConfig,

});

expect(runEmbeddedAgentMock).toHaveBeenCalledOnce();

expect(requireFirstRunOptions().authProfileFailurePolicy).toBe("local");

});

it("honors configured agent timeoutSeconds for slow local providers", async () => {

await generateSlugViaLLM({

sessionContent: "hello",

timeoutMs,

runId: `slug-gen-${Date.now()}`,

cleanupBundleMcpOnRunEnd: true,

// Internal helper run: route failures lane-local so an upstream 400/billing

// here cannot poison the shared profile (#71709).

authProfileFailurePolicy: "local",

});

// Extract text from payloads

return Boolean(value) && typeof value === "object" && !Array.isArray(value);

}

function parseDeviceAuthEntry(role: string, value: unknown): DeviceAuthEntry | null {

if (

!isRecord(value) ||

typeof value.token !== "string" ||

!Array.isArray(value.scopes) ||

!value.scopes.every((scope) => typeof scope === "string") ||

typeof value.updatedAtMs !== "number" ||

!Number.isFinite(value.updatedAtMs)

) {

return null;

}

return {

token: value.token,

role,

scopes: value.scopes,

updatedAtMs: value.updatedAtMs,

};

}

function parseDeviceAuthStore(value: unknown): DeviceAuthStore | null {

if (!isRecord(value) || value.version !== 1 || typeof value.deviceId !== "string") {

return null;

}

if (!isRecord(value.tokens)) {

return null;

}

const tokens: Record<string, DeviceAuthEntry> = {};

for (const [role, rawEntry] of Object.entries(value.tokens)) {

const entry = parseDeviceAuthEntry(role, rawEntry);

if (entry) {

tokens[role] = entry;

}

}

return {

version: 1,

deviceId: value.deviceId,

tokens: value.tokens,

tokens,

};

}

`No API key resolved for provider "${provider}" (auth mode: ${auth?.mode}).`,

);

},

isProviderAuthError: vi.fn(() => false),

resolveAwsSdkEnvVarName: vi.fn(() => undefined),

resolveEnvApiKey: vi.fn(() => null),

resolveModelAuthMode: vi.fn(() => "api-key"),

`No API key resolved for provider "${provider}" (auth mode: ${auth?.mode}).`,

);

},

isProviderAuthError: vi.fn(() => false),

}));

vi.doMock("../media/fetch.js", () => ({

readRemoteMediaBuffer: readRemoteMediaBufferMock,

cfg: createGroqAudioConfig(),

providers: createGroqProviders(),

});

expect(result.appliedAudio).toBe(true);

expectTranscriptApplied({

ctx,

import { vi } from "vitest";

export function createAvailableModelAuthMockModule() {

class ProviderAuthError extends Error {

constructor(

readonly code: "missing-api-key" | "missing-provider-auth",

readonly provider: string,

message: string,

) {

super(message);

this.name = "ProviderAuthError";

}

}

return {

hasAvailableAuthForProvider: vi.fn(() => true),

resolveApiKeyForProvider: vi.fn(async () => ({

mode: "api-key",

})),

requireApiKey: vi.fn((auth: { apiKey?: string }) => auth.apiKey ?? "test-key"),

ProviderAuthError,

isProviderAuthError: vi.fn(

(err: unknown, code?: "missing-api-key" | "missing-provider-auth") =>

err instanceof ProviderAuthError && (!code || err.code === code),

),

};

}