};

});

const { buildAnthropicCliMigrationResult, hasClaudeCliAuth } = await import("./cli-migration.js");

const { buildAnthropicCliMigrationResult } = await import("./cli-migration.js");

const { resolveKnownAnthropicModelRef } = await import("./claude-model-refs.js");

const { createTestWizardPrompter, registerSingleProviderPlugin } =

await import("openclaw/plugin-sdk/plugin-test-runtime");

}

describe("anthropic cli migration", () => {

it("detects local Claude CLI auth", () => {

readClaudeCliCredentialsForSetup.mockReturnValue({ type: "oauth" });

expect(hasClaudeCliAuth()).toBe(true);

});

it("uses the non-interactive Claude auth probe without keychain prompts", () => {

readClaudeCliCredentialsForSetup.mockReset();

readClaudeCliCredentialsForSetupNonInteractive.mockReset();

readClaudeCliCredentialsForSetup.mockReturnValue(null);

readClaudeCliCredentialsForSetupNonInteractive.mockReturnValue({ type: "oauth" });

expect(hasClaudeCliAuth({ allowKeychainPrompt: false })).toBe(true);

expect(readClaudeCliCredentialsForSetup).not.toHaveBeenCalled();

expect(readClaudeCliCredentialsForSetupNonInteractive).toHaveBeenCalledTimes(1);

});

it("keeps anthropic defaults and selects the claude-cli runtime", () => {

const result = buildAnthropicCliMigrationResult({

agents: {

normalizeLowercaseStringOrEmpty,

} from "openclaw/plugin-sdk/string-coerce-runtime";

import { resolveClaudeCliAnthropicModelRefs } from "./claude-model-refs.js";

import {

readClaudeCliCredentialsForSetup,

readClaudeCliCredentialsForSetupNonInteractive,

} from "./cli-auth-seam.js";

import type { readClaudeCliCredentialsForSetup } from "./cli-auth-seam.js";

import { CLAUDE_CLI_BACKEND_ID, CLAUDE_CLI_DEFAULT_ALLOWLIST_REFS } from "./cli-shared.js";

type AgentDefaultsModel = NonNullable<NonNullable<OpenClawConfig["agents"]>["defaults"]>["model"];

return base;

}

/** Return whether Claude CLI credentials are available for setup migration. */

export function hasClaudeCliAuth(options?: { allowKeychainPrompt?: boolean }): boolean {

return Boolean(

options?.allowKeychainPrompt === false

? readClaudeCliCredentialsForSetupNonInteractive()

: readClaudeCliCredentialsForSetup(),

);

}

function buildClaudeCliAuthProfiles(

credential?: ClaudeCliCredential | null,

): ProviderAuthResult["profiles"] {

// Discord provider module implements model/runtime integration.

import { warn, type RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";

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

import { Client, overwriteApplicationCommands, type RequestClient } from "../internal/discord.js";

import { Client, type RequestClient } from "../internal/discord.js";

import {

attachDiscordDeployRestContext,

attachDiscordDeployRequestBody,

);

});

}

export async function clearDiscordNativeCommands(params: {

client: Client;

applicationId: string;

runtime: RuntimeEnv;

}) {

try {

await overwriteApplicationCommands(params.client.rest, params.applicationId, []);

params.runtime.log?.("discord: cleared native commands (commands.native=false)");

} catch (err) {

params.runtime.error?.(`discord: failed to clear native commands: ${String(err)}`);

}

}

return { cfg, agentId };

}

export async function getMemoryManagerContext(params: {

cfg: OpenClawConfig;

agentId: string;

}): Promise<

| {

manager: NonNullable<MemorySearchManagerResult["manager"]>;

}

| {

error: string | undefined;

}

> {

return await getMemoryManagerContextWithPurpose({ ...params, purpose: undefined });

}

export async function getMemoryManagerContextWithPurpose(params: {

cfg: OpenClawConfig;

agentId: string;

},

};

}

export const openRouterMusicTestInternals = {

readOpenRouterAudioStream,

};

cursor = parent;

}

}

export function setReadOpenFlagsResolverForTest(

_resolver: (() => { flags: number; supportsNoFollow: boolean }) | undefined,

): void {

// Retained for older OpenShell tests; pinned reads now delegate to fs-safe.

}