remoteclaw 0.1.0-next.049f396 → 0.1.0-next.05abcca

package/dist/plugin-auto-enable-DghjlFCL.js

@@ -0,0 +1,301 @@
+import { A as normalizeChatChannelId, D as listChatChannels, E as getChatChannelMeta, Y as isRecord } from "./entry.js";
+import { S as loadPluginManifestRegistry } from "./config-BTH7fB_v.js";
+import { a as normalizeProviderId } from "./provider-utils-DiLhkKQp.js";
+import { t as hasAnyWhatsAppAuth } from "./accounts-CIVjmTg9.js";
+import { n as getChannelPluginCatalogEntry, r as listChannelPluginCatalogEntries } from "./catalog-k056Nh93.js";
+import { t as ensurePluginAllowlisted } from "./plugins-allowlist-D2tS9tcu.js";
+
+//#region src/config/plugin-auto-enable.ts
+const CHANNEL_PLUGIN_IDS = Array.from(new Set([...listChatChannels().map((meta) => meta.id), ...listChannelPluginCatalogEntries().map((entry) => entry.id)]));
+const PROVIDER_PLUGIN_IDS = [];
+function hasNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function recordHasKeys(value) {
+	return isRecord(value) && Object.keys(value).length > 0;
+}
+function accountsHaveKeys(value, keys) {
+	if (!isRecord(value)) return false;
+	for (const account of Object.values(value)) {
+		if (!isRecord(account)) continue;
+		for (const key of keys) if (hasNonEmptyString(account[key])) return true;
+	}
+	return false;
+}
+function resolveChannelConfig(cfg, channelId) {
+	const entry = cfg.channels?.[channelId];
+	return isRecord(entry) ? entry : null;
+}
+const STRUCTURED_CHANNEL_CONFIG_SPECS = {
+	telegram: {
+		envAny: ["TELEGRAM_BOT_TOKEN"],
+		stringKeys: ["botToken", "tokenFile"],
+		accountStringKeys: ["botToken", "tokenFile"]
+	},
+	discord: {
+		envAny: ["DISCORD_BOT_TOKEN"],
+		stringKeys: ["token"],
+		accountStringKeys: ["token"]
+	},
+	irc: {
+		envAll: ["IRC_HOST", "IRC_NICK"],
+		stringKeys: ["host", "nick"],
+		accountStringKeys: ["host", "nick"]
+	},
+	slack: {
+		envAny: [
+			"SLACK_BOT_TOKEN",
+			"SLACK_APP_TOKEN",
+			"SLACK_USER_TOKEN"
+		],
+		stringKeys: [
+			"botToken",
+			"appToken",
+			"userToken"
+		],
+		accountStringKeys: [
+			"botToken",
+			"appToken",
+			"userToken"
+		]
+	},
+	signal: {
+		stringKeys: [
+			"account",
+			"httpUrl",
+			"httpHost",
+			"cliPath"
+		],
+		numberKeys: ["httpPort"],
+		accountStringKeys: [
+			"account",
+			"httpUrl",
+			"httpHost",
+			"cliPath"
+		]
+	},
+	imessage: { stringKeys: ["cliPath"] }
+};
+function envHasAnyKeys(env, keys) {
+	for (const key of keys) if (hasNonEmptyString(env[key])) return true;
+	return false;
+}
+function envHasAllKeys(env, keys) {
+	for (const key of keys) if (!hasNonEmptyString(env[key])) return false;
+	return keys.length > 0;
+}
+function hasAnyNumberKeys(entry, keys) {
+	for (const key of keys) if (typeof entry[key] === "number") return true;
+	return false;
+}
+function isStructuredChannelConfigured(cfg, channelId, env, spec) {
+	if (spec.envAny && envHasAnyKeys(env, spec.envAny)) return true;
+	if (spec.envAll && envHasAllKeys(env, spec.envAll)) return true;
+	const entry = resolveChannelConfig(cfg, channelId);
+	if (!entry) return false;
+	if (spec.stringKeys && spec.stringKeys.some((key) => hasNonEmptyString(entry[key]))) return true;
+	if (spec.numberKeys && hasAnyNumberKeys(entry, spec.numberKeys)) return true;
+	if (spec.accountStringKeys && accountsHaveKeys(entry.accounts, spec.accountStringKeys)) return true;
+	return recordHasKeys(entry);
+}
+function isWhatsAppConfigured(cfg) {
+	if (hasAnyWhatsAppAuth(cfg)) return true;
+	const entry = resolveChannelConfig(cfg, "whatsapp");
+	if (!entry) return false;
+	return recordHasKeys(entry);
+}
+function isGenericChannelConfigured(cfg, channelId) {
+	return recordHasKeys(resolveChannelConfig(cfg, channelId));
+}
+function isChannelConfigured(cfg, channelId, env = process.env) {
+	if (channelId === "whatsapp") return isWhatsAppConfigured(cfg);
+	const spec = STRUCTURED_CHANNEL_CONFIG_SPECS[channelId];
+	if (spec) return isStructuredChannelConfigured(cfg, channelId, env, spec);
+	return isGenericChannelConfigured(cfg, channelId);
+}
+function collectModelRefs(cfg) {
+	const refs = [];
+	const pushModelRef = (value) => {
+		if (typeof value === "string" && value.trim()) refs.push(value.trim());
+	};
+	const collectFromAgent = (agent) => {
+		if (!agent) return;
+		const model = agent.model;
+		if (typeof model === "string") pushModelRef(model);
+		else if (isRecord(model)) {
+			pushModelRef(model.primary);
+			const fallbacks = model.fallbacks;
+			if (Array.isArray(fallbacks)) for (const entry of fallbacks) pushModelRef(entry);
+		}
+		const models = agent.models;
+		if (isRecord(models)) for (const key of Object.keys(models)) pushModelRef(key);
+	};
+	const defaults = cfg.agents?.defaults;
+	collectFromAgent(defaults);
+	const list = cfg.agents?.list;
+	if (Array.isArray(list)) {
+		for (const entry of list) if (isRecord(entry)) collectFromAgent(entry);
+	}
+	return refs;
+}
+function extractProviderFromModelRef(value) {
+	const trimmed = value.trim();
+	const slash = trimmed.indexOf("/");
+	if (slash <= 0) return null;
+	return normalizeProviderId(trimmed.slice(0, slash));
+}
+function isProviderConfigured(cfg, providerId) {
+	const normalized = normalizeProviderId(providerId);
+	const profiles = cfg.auth?.profiles;
+	if (profiles && typeof profiles === "object") for (const profile of Object.values(profiles)) {
+		if (!isRecord(profile)) continue;
+		if (normalizeProviderId(String(profile.provider ?? "")) === normalized) return true;
+	}
+	const modelRefs = collectModelRefs(cfg);
+	for (const ref of modelRefs) {
+		const provider = extractProviderFromModelRef(ref);
+		if (provider && provider === normalized) return true;
+	}
+	return false;
+}
+function buildChannelToPluginIdMap(registry) {
+	const map = /* @__PURE__ */ new Map();
+	for (const record of registry.plugins) for (const channelId of record.channels) if (channelId && !map.has(channelId)) map.set(channelId, record.id);
+	return map;
+}
+function resolvePluginIdForChannel(channelId, channelToPluginId) {
+	const builtInId = normalizeChatChannelId(channelId);
+	if (builtInId) return builtInId;
+	return channelToPluginId.get(channelId) ?? channelId;
+}
+function collectCandidateChannelIds(cfg) {
+	const channelIds = new Set(CHANNEL_PLUGIN_IDS);
+	const configuredChannels = cfg.channels;
+	if (!configuredChannels || typeof configuredChannels !== "object") return Array.from(channelIds);
+	for (const key of Object.keys(configuredChannels)) {
+		if (key === "defaults" || key === "modelByChannel") continue;
+		const normalizedBuiltIn = normalizeChatChannelId(key);
+		channelIds.add(normalizedBuiltIn ?? key);
+	}
+	return Array.from(channelIds);
+}
+function resolveConfiguredPlugins(cfg, env, registry) {
+	const changes = [];
+	const channelToPluginId = buildChannelToPluginIdMap(registry);
+	for (const channelId of collectCandidateChannelIds(cfg)) {
+		const pluginId = resolvePluginIdForChannel(channelId, channelToPluginId);
+		if (isChannelConfigured(cfg, channelId, env)) changes.push({
+			pluginId,
+			reason: `${channelId} configured`
+		});
+	}
+	for (const mapping of PROVIDER_PLUGIN_IDS) if (isProviderConfigured(cfg, mapping.providerId)) changes.push({
+		pluginId: mapping.pluginId,
+		reason: `${mapping.providerId} auth configured`
+	});
+	return changes;
+}
+function isPluginExplicitlyDisabled(cfg, pluginId) {
+	const builtInChannelId = normalizeChatChannelId(pluginId);
+	if (builtInChannelId) {
+		const channelConfig = cfg.channels?.[builtInChannelId];
+		if (channelConfig && typeof channelConfig === "object" && !Array.isArray(channelConfig) && channelConfig.enabled === false) return true;
+	}
+	return (cfg.plugins?.entries?.[pluginId])?.enabled === false;
+}
+function isPluginDenied(cfg, pluginId) {
+	const deny = cfg.plugins?.deny;
+	return Array.isArray(deny) && deny.includes(pluginId);
+}
+function resolvePreferredOverIds(pluginId) {
+	const normalized = normalizeChatChannelId(pluginId);
+	if (normalized) return getChatChannelMeta(normalized).preferOver ?? [];
+	return getChannelPluginCatalogEntry(pluginId)?.meta.preferOver ?? [];
+}
+function shouldSkipPreferredPluginAutoEnable(cfg, entry, configured) {
+	for (const other of configured) {
+		if (other.pluginId === entry.pluginId) continue;
+		if (isPluginDenied(cfg, other.pluginId)) continue;
+		if (isPluginExplicitlyDisabled(cfg, other.pluginId)) continue;
+		if (resolvePreferredOverIds(other.pluginId).includes(entry.pluginId)) return true;
+	}
+	return false;
+}
+function registerPluginEntry(cfg, pluginId) {
+	const builtInChannelId = normalizeChatChannelId(pluginId);
+	if (builtInChannelId) {
+		const existing = cfg.channels?.[builtInChannelId];
+		const existingRecord = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				[builtInChannelId]: {
+					...existingRecord,
+					enabled: true
+				}
+			}
+		};
+	}
+	const entries = {
+		...cfg.plugins?.entries,
+		[pluginId]: {
+			...cfg.plugins?.entries?.[pluginId],
+			enabled: true
+		}
+	};
+	return {
+		...cfg,
+		plugins: {
+			...cfg.plugins,
+			entries
+		}
+	};
+}
+function formatAutoEnableChange(entry) {
+	let reason = entry.reason.trim();
+	const channelId = normalizeChatChannelId(entry.pluginId);
+	if (channelId) {
+		const label = getChatChannelMeta(channelId).label;
+		reason = reason.replace(new RegExp(`^${channelId}\\b`, "i"), label);
+	}
+	return `${reason}, enabled automatically.`;
+}
+function applyPluginAutoEnable(params) {
+	const env = params.env ?? process.env;
+	const registry = params.manifestRegistry ?? loadPluginManifestRegistry({ config: params.config });
+	const configured = resolveConfiguredPlugins(params.config, env, registry);
+	if (configured.length === 0) return {
+		config: params.config,
+		changes: []
+	};
+	let next = params.config;
+	const changes = [];
+	if (next.plugins?.enabled === false) return {
+		config: next,
+		changes
+	};
+	for (const entry of configured) {
+		const builtInChannelId = normalizeChatChannelId(entry.pluginId);
+		if (isPluginDenied(next, entry.pluginId)) continue;
+		if (isPluginExplicitlyDisabled(next, entry.pluginId)) continue;
+		if (shouldSkipPreferredPluginAutoEnable(next, entry, configured)) continue;
+		const allow = next.plugins?.allow;
+		const allowMissing = Array.isArray(allow) && !allow.includes(entry.pluginId);
+		if ((builtInChannelId != null ? (() => {
+			const channelConfig = next.channels?.[builtInChannelId];
+			if (!channelConfig || typeof channelConfig !== "object" || Array.isArray(channelConfig)) return false;
+			return channelConfig.enabled === true;
+		})() : next.plugins?.entries?.[entry.pluginId]?.enabled === true) && !allowMissing) continue;
+		next = registerPluginEntry(next, entry.pluginId);
+		if (allowMissing || !builtInChannelId) next = ensurePluginAllowlisted(next, entry.pluginId);
+		changes.push(formatAutoEnableChange(entry));
+	}
+	return {
+		config: next,
+		changes
+	};
+}
+
+//#endregion
+export { isChannelConfigured as n, applyPluginAutoEnable as t };

package/dist/plugin-registry-68h2T8vi.js

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { t as createSubsystemLogger, v as getActivePluginRegistry } from "./subsystem-BAW_f3DI.js";
+import { c as resolveDefaultAgentId, s as resolveAgentWorkspaceDirOrNull } from "./agent-scope-CAQLm3LP.js";
+import { i as loadConfig } from "./config-DwuBnd6D.js";
+import { t as loadRemoteClawPlugins } from "./loader-DXbpue-L.js";
+
+//#region src/cli/plugin-registry.ts
+var plugin_registry_exports = /* @__PURE__ */ __exportAll({ ensurePluginRegistryLoaded: () => ensurePluginRegistryLoaded });
+const log = createSubsystemLogger("plugins");
+let pluginRegistryLoaded = false;
+function ensurePluginRegistryLoaded() {
+	if (pluginRegistryLoaded) return;
+	const active = getActivePluginRegistry();
+	if (active && (active.plugins.length > 0 || active.channels.length > 0 || active.tools.length > 0)) {
+		pluginRegistryLoaded = true;
+		return;
+	}
+	const config = loadConfig();
+	loadRemoteClawPlugins({
+		config,
+		workspaceDir: resolveAgentWorkspaceDirOrNull(config, resolveDefaultAgentId(config)) ?? void 0,
+		logger: {
+			info: (msg) => log.info(msg),
+			warn: (msg) => log.warn(msg),
+			error: (msg) => log.error(msg),
+			debug: (msg) => log.debug(msg)
+		}
+	});
+	pluginRegistryLoaded = true;
+}
+
+//#endregion
+export { plugin_registry_exports as n, ensurePluginRegistryLoaded as t };

package/dist/plugin-registry-BitdVPb4.js

@@ -0,0 +1,33 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { j as getActivePluginRegistry, o as createSubsystemLogger } from "./entry.js";
+import { i as loadConfig } from "./config-BTH7fB_v.js";
+import { c as resolveDefaultAgentId, s as resolveAgentWorkspaceDirOrNull } from "./agent-scope-BA1HP4K6.js";
+import { t as loadRemoteClawPlugins } from "./loader-BoP3JA-r.js";
+
+//#region src/cli/plugin-registry.ts
+var plugin_registry_exports = /* @__PURE__ */ __exportAll({ ensurePluginRegistryLoaded: () => ensurePluginRegistryLoaded });
+const log = createSubsystemLogger("plugins");
+let pluginRegistryLoaded = false;
+function ensurePluginRegistryLoaded() {
+	if (pluginRegistryLoaded) return;
+	const active = getActivePluginRegistry();
+	if (active && (active.plugins.length > 0 || active.channels.length > 0 || active.tools.length > 0)) {
+		pluginRegistryLoaded = true;
+		return;
+	}
+	const config = loadConfig();
+	loadRemoteClawPlugins({
+		config,
+		workspaceDir: resolveAgentWorkspaceDirOrNull(config, resolveDefaultAgentId(config)) ?? void 0,
+		logger: {
+			info: (msg) => log.info(msg),
+			warn: (msg) => log.warn(msg),
+			error: (msg) => log.error(msg),
+			debug: (msg) => log.debug(msg)
+		}
+	});
+	pluginRegistryLoaded = true;
+}
+
+//#endregion
+export { plugin_registry_exports as n, ensurePluginRegistryLoaded as t };

package/dist/plugin-sdk/agents/agent-helpers.d.ts

@@ -4,7 +4,6 @@ export { isGoogleModelApi, sanitizeGoogleTurnOrdering } from "./agent-helpers/go
 export { downgradeOpenAIReasoningBlocks } from "./agent-helpers/openai.js";
 export { isEmptyAssistantMessageContent, sanitizeSessionMessagesImages, } from "./agent-helpers/images.js";
 export { isMessagingToolDuplicate, isMessagingToolDuplicateNormalized, normalizeTextForComparison, } from "./agent-helpers/messaging-dedupe.js";
-export { pickFallbackThinkingLevel } from "./agent-helpers/thinking.js";
 export { mergeConsecutiveUserTurns, validateAnthropicTurns, validateGeminiTurns, } from "./agent-helpers/turns.js";
 export type { FailoverReason } from "./agent-helpers/types.js";
 export type { ToolCallIdMode } from "./tool-call-id.js";

package/dist/plugin-sdk/agents/agent-scope.d.ts

@@ -16,6 +16,7 @@ type ResolvedAgentConfig = {
     subagents?: AgentEntry["subagents"];
     sandbox?: AgentEntry["sandbox"];
     tools?: AgentEntry["tools"];
+    auth?: AgentEntry["auth"];
 };
 export declare function listAgentEntries(cfg: RemoteClawConfig): AgentEntry[];
 export declare function listAgentIds(cfg: RemoteClawConfig): string[];
@@ -33,6 +34,15 @@ export declare function resolveSessionAgentId(params: {
     config?: RemoteClawConfig;
 }): string;
 export declare function resolveAgentConfig(cfg: RemoteClawConfig, agentId: string): ResolvedAgentConfig | undefined;
+/**
+ * Resolve the effective auth setting for an agent.
+ *
+ * Resolution: agent entry `auth` overrides `agents.defaults.auth`.
+ * - Explicit `auth: false` on the entry is an opt-out (not the same as undefined).
+ * - `undefined` (missing) on the entry inherits from defaults.
+ * - Returns `undefined` when neither the entry nor defaults define auth.
+ */
+export declare function resolveAgentAuth(cfg: RemoteClawConfig, agentId: string): false | string | string[] | undefined;
 export declare function resolveAgentExplicitModelPrimary(cfg: RemoteClawConfig, agentId: string): string | undefined;
 export declare function resolveAgentEffectiveModelPrimary(cfg: RemoteClawConfig, agentId: string): string | undefined;
 export declare function resolveAgentModelPrimary(cfg: RemoteClawConfig, agentId: string): string | undefined;
@@ -57,4 +67,5 @@ export declare function resolveEffectiveModelFallbacks(params: {
     hasSessionModelOverride: boolean;
 }): string[] | undefined;
 export declare function resolveAgentWorkspaceDir(cfg: RemoteClawConfig, agentId: string): string;
+export declare function resolveAgentWorkspaceDirOrNull(cfg: RemoteClawConfig, agentId: string): string | null;
 export declare function resolveAgentDir(cfg: RemoteClawConfig, agentId: string): string;

package/dist/plugin-sdk/agents/agent-types.d.ts

@@ -8,11 +8,6 @@ export interface ImageContent {
     data: string;
     mimeType: string;
 }
-export interface ThinkingContent {
-    type: "thinking";
-    thinking: string;
-    thinkingSignature?: string;
-}
 export interface ToolCall {
     type: "toolCall";
     id: string;
@@ -27,7 +22,7 @@ export interface UserMessage {
 }
 export interface AssistantMessage {
     role: "assistant";
-    content: (TextContent | ThinkingContent | ToolCall)[];
+    content: (TextContent | ToolCall)[];
     api: string;
     provider: string;
     model: string;

package/dist/plugin-sdk/agents/agent-utils.d.ts

@@ -22,18 +22,4 @@ export declare function stripDowngradedToolCallText(text: string): string;
  */
 export declare function stripThinkingTagsFromText(text: string): string;
 export declare function extractAssistantText(msg: AssistantMessage): string;
-export declare function extractAssistantThinking(msg: AssistantMessage): string;
-export declare function formatReasoningMessage(text: string): string;
-type ThinkTaggedSplitBlock = {
-    type: "thinking";
-    thinking: string;
-} | {
-    type: "text";
-    text: string;
-};
-export declare function splitThinkingTaggedText(text: string): ThinkTaggedSplitBlock[] | null;
-export declare function promoteThinkingTagsToBlocks(message: AssistantMessage): void;
-export declare function extractThinkingFromTaggedText(text: string): string;
-export declare function extractThinkingFromTaggedStream(text: string): string;
 export declare function inferToolMetaFromArgs(toolName: string, args: unknown): string | undefined;
-export {};

package/dist/plugin-sdk/agents/provider-utils.d.ts

@@ -10,7 +10,6 @@ export type ModelRef = {
     provider: string;
     model: string;
 };
-export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 export declare function modelKey(provider: string, model: string): string;
 export declare function normalizeProviderId(provider: string): string;
 export declare function findNormalizedProviderValue<T>(entries: Record<string, T> | undefined, provider: string): T | undefined;

package/dist/plugin-sdk/agents/subagent-registry.store.d.ts

@@ -1,5 +1,4 @@
 import type { SubagentRunRecord } from "./subagent-registry.types.js";
-export type PersistedSubagentRegistryVersion = 1 | 2;
 export declare function resolveSubagentRegistryPath(): string;
 export declare function loadSubagentRegistryFromDisk(): Map<string, SubagentRunRecord>;
 export declare function saveSubagentRegistryToDisk(runs: Map<string, SubagentRunRecord>): void;

package/dist/plugin-sdk/agents/subagent-spawn.d.ts

@@ -5,7 +5,6 @@ export type SpawnSubagentParams = {
     label?: string;
     agentId?: string;
     model?: string;
-    thinking?: string;
     runTimeoutSeconds?: number;
     thread?: boolean;
     mode?: SpawnSubagentMode;

package/dist/plugin-sdk/agents/tools/sessions-helpers.d.ts

@@ -20,7 +20,6 @@ export type SessionListRow = {
     model?: string;
     contextTokens?: number | null;
     totalTokens?: number | null;
-    thinkingLevel?: string;
     verboseLevel?: string;
     systemSent?: boolean;
     abortedLastRun?: boolean;

package/dist/plugin-sdk/auth/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const AUTH_STORE_VERSION = 1;
+export declare const AUTH_PROFILE_FILENAME = "auth-profiles.json";
+export declare const CLAUDE_CLI_PROFILE_ID = "anthropic:claude-cli";
+export declare const CODEX_CLI_PROFILE_ID = "openai-codex:codex-cli";
+export declare const AUTH_STORE_LOCK_OPTIONS: {
+    readonly retries: {
+        readonly retries: 10;
+        readonly factor: 2;
+        readonly minTimeout: 100;
+        readonly maxTimeout: 10000;
+        readonly randomize: true;
+    };
+    readonly stale: 30000;
+};
+export declare const log: import("../logging/subsystem.js").SubsystemLogger;

package/dist/plugin-sdk/auth/display.d.ts

@@ -0,0 +1,7 @@
+import type { RemoteClawConfig } from "../config/config.js";
+import type { AuthProfileStore } from "./types.js";
+export declare function resolveAuthProfileDisplayLabel(params: {
+    cfg?: RemoteClawConfig;
+    store: AuthProfileStore;
+    profileId: string;
+}): string;

package/dist/plugin-sdk/auth/doctor.d.ts

@@ -0,0 +1,8 @@
+import type { RemoteClawConfig } from "../config/config.js";
+import type { AuthProfileStore } from "./types.js";
+export declare function formatAuthDoctorHint(params: {
+    cfg?: RemoteClawConfig;
+    store: AuthProfileStore;
+    provider: string;
+    profileId?: string;
+}): string;

package/dist/plugin-sdk/auth/env-injection.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Auth profile -> CLI subprocess env var injection.
+ *
+ * Resolves per-agent auth profile references to environment variables
+ * suitable for injecting into CLI subprocess environments.
+ */
+import type { RemoteClawConfig } from "../config/config.js";
+import type { AuthProfileStore } from "./types.js";
+/**
+ * Map a provider ID to the primary environment variable name used by CLI agents.
+ *
+ * Returns `undefined` for providers with no known env var mapping.
+ */
+export declare function resolveProviderEnvVarName(provider: string): string | undefined;
+/**
+ * Return the number of auth profiles configured for an agent.
+ *
+ * - `auth: false` or `undefined` -> 0
+ * - `auth: "profile-id"` -> 1
+ * - `auth: ["id1", "id2"]` -> N
+ */
+export declare function resolveAuthProfileCount(cfg: RemoteClawConfig, agentId: string): number;
+/**
+ * Resolve per-agent auth profile(s) to env vars for CLI subprocess injection.
+ *
+ * - `auth: false` -> no injection (returns `undefined`)
+ * - `auth: "profile-id"` -> resolve single profile, inject as env var
+ * - `auth: ["id1", "id2"]` -> persistent cooldown-aware round-robin, inject selected profile
+ * - `auth: undefined` -> no injection (returns `undefined`)
+ *
+ * Missing or invalid profiles log a warning and return `undefined`
+ * (fall-through to next credential precedence level).
+ */
+export declare function resolveAuthEnv(params: {
+    cfg: RemoteClawConfig;
+    agentId: string;
+    store?: AuthProfileStore;
+}): Promise<Record<string, string> | undefined>;

package/dist/plugin-sdk/auth/index.d.ts

@@ -0,0 +1,10 @@
+export { CLAUDE_CLI_PROFILE_ID, CODEX_CLI_PROFILE_ID } from "./constants.js";
+export { resolveAuthProfileDisplayLabel } from "./display.js";
+export { formatAuthDoctorHint } from "./doctor.js";
+export { resolveApiKeyForProfile } from "./oauth.js";
+export { resolveAuthProfileOrder } from "./order.js";
+export { resolveAuthStorePathForDisplay } from "./paths.js";
+export { dedupeProfileIds, listProfilesForProvider, upsertAuthProfile, upsertAuthProfileWithLock, } from "./profiles.js";
+export { ensureAuthProfileStore, loadAuthProfileStore, saveAuthProfileStore } from "./store.js";
+export type { ApiKeyCredential, AuthProfileCredential, AuthProfileFailureReason, AuthProfileStore, ProfileUsageStats, } from "./types.js";
+export { calculateAuthProfileCooldownMs, clearAuthProfileCooldown, clearExpiredCooldowns, getSoonestCooldownExpiry, isProfileInCooldown, markAuthProfileCooldown, markAuthProfileFailure, markAuthProfileUsed, resolveProfilesUnavailableReason, resolveProfileUnusableUntil, resolveProfileUnusableUntilForDisplay, } from "./usage.js";

package/dist/plugin-sdk/auth/oauth.d.ts

@@ -0,0 +1,13 @@
+import type { RemoteClawConfig } from "../config/config.js";
+import type { AuthProfileStore } from "./types.js";
+type ResolveApiKeyForProfileParams = {
+    cfg?: RemoteClawConfig;
+    store: AuthProfileStore;
+    profileId: string;
+};
+export declare function resolveApiKeyForProfile(params: ResolveApiKeyForProfileParams): Promise<{
+    apiKey: string;
+    provider: string;
+    email?: string;
+} | null>;
+export {};

package/dist/plugin-sdk/auth/order.d.ts

@@ -0,0 +1,8 @@
+import type { RemoteClawConfig } from "../config/config.js";
+import type { AuthProfileStore } from "./types.js";
+export declare function resolveAuthProfileOrder(params: {
+    cfg?: RemoteClawConfig;
+    store: AuthProfileStore;
+    provider: string;
+    preferredProfile?: string;
+}): string[];

package/dist/plugin-sdk/auth/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveAuthStorePath(): string;
+export declare function resolveAuthStorePathForDisplay(): string;
+export declare function ensureAuthStoreFile(pathname: string): void;

package/dist/plugin-sdk/auth/profiles.d.ts

@@ -0,0 +1,11 @@
+import type { AuthProfileCredential, AuthProfileStore } from "./types.js";
+export declare function dedupeProfileIds(profileIds: string[]): string[];
+export declare function upsertAuthProfile(params: {
+    profileId: string;
+    credential: AuthProfileCredential;
+}): void;
+export declare function upsertAuthProfileWithLock(params: {
+    profileId: string;
+    credential: AuthProfileCredential;
+}): Promise<AuthProfileStore | null>;
+export declare function listProfilesForProvider(store: AuthProfileStore, provider: string): string[];

package/dist/plugin-sdk/auth/provider-auth.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Provider auth resolution extracted from model-auth.ts.
+ *
+ * Resolves API keys for providers via auth profiles, environment variables,
+ * and AWS SDK credential chains. Used by media-understanding, onboarding,
+ * and status display.
+ */
+import type { RemoteClawConfig } from "../config/config.js";
+import { type AuthProfileStore } from "./index.js";
+export { ensureAuthProfileStore } from "./index.js";
+export declare function resolveAwsSdkEnvVarName(env?: NodeJS.ProcessEnv): string | undefined;
+export type ResolvedProviderAuth = {
+    apiKey?: string;
+    profileId?: string;
+    source: string;
+    mode: "api-key";
+};
+export declare function resolveApiKeyForProvider(params: {
+    provider: string;
+    cfg?: RemoteClawConfig;
+    profileId?: string;
+    preferredProfile?: string;
+    store?: AuthProfileStore;
+}): Promise<ResolvedProviderAuth>;
+export type EnvApiKeyResult = {
+    apiKey: string;
+    source: string;
+};
+export type ModelAuthMode = "api-key" | "unknown";
+export declare function resolveEnvApiKey(provider: string): EnvApiKeyResult | null;
+export declare function resolveModelAuthMode(provider?: string, cfg?: RemoteClawConfig, store?: AuthProfileStore): ModelAuthMode | undefined;
+export declare function requireApiKey(auth: ResolvedProviderAuth, provider: string): string;

package/dist/plugin-sdk/auth/store.d.ts

@@ -0,0 +1,7 @@
+import type { AuthProfileStore } from "./types.js";
+export declare function updateAuthProfileStoreWithLock(params: {
+    updater: (store: AuthProfileStore) => boolean;
+}): Promise<AuthProfileStore | null>;
+export declare function loadAuthProfileStore(): AuthProfileStore;
+export declare function ensureAuthProfileStore(): AuthProfileStore;
+export declare function saveAuthProfileStore(store: AuthProfileStore): void;