@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/agent/tools/index.d.ts

@@ -37,6 +37,7 @@ export { createSkillInstallTool, type SkillInstallToolDeps, type SkillInstallToo
 export { createToolManualTool } from './tool-manual-tool.js';
 export { createDesktopPetTool, type DesktopPetCreateDetails } from './desktop-pet-tool.js';
 export { createCodeIntelligenceTools } from '../code-intelligence/tools.js';
+export { createManagedJobTool } from './managed-job-tool.js';
 export { createImageTool, resolveImageModelConfigForTool } from './image-tool.js';
 export { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from './image-generate-tool.js';
 export { truncateHead, truncateTail, truncateLine, formatSize, type TruncationResult, type TruncationOptions, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES, GREP_MAX_LINE_LENGTH, } from './truncate.js';

package/dist/src/agent/tools/index.js

@@ -41,7 +41,8 @@ import { createSkillInstallTool } from "./skill-install-tool.js";
 import { createToolManualTool } from "./tool-manual-tool.js";
 import { createDesktopPetTool } from "./desktop-pet-tool.js";
 import { createCodeIntelligenceTools } from "../code-intelligence/tools.js";
+import { createManagedJobTool } from "./managed-job-tool.js";
 import { resolveImageModelConfigForTool } from "../image/tool-model-config.js";
 import { createImageTool } from "./image-tool.js";
 import { createImageGenerateTool, resolveImageGenerationModelConfigForTool } from "./image-generate-tool.js";
-export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCodeIntelligenceTools, createComposioTools, createCreateShareTool, createCuratedMemoryTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGoalTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };
+export { BrowserManager, DEFAULT_DELEGATE_TOOLS, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, DEFAULT_TOOL_METADATA, DEFAULT_WEB_EXTRACT_MAX_LENGTH, DELEGATE_BLOCKED_TOOLS, GREP_MAX_LINE_LENGTH, MAX_RAW_HTML_CHARS_FOR_WEB_EXTRACT, SANDBOX_ALLOWED_TOOLS, TodoStore, ToolConcurrencyController, assertBrowserUrlAllowed, buildSandboxToolMap, createApplyPatchTool, createAutomationTool, createBrowserRecipeTool, createClarifyTool, createCodeIntelligenceTools, createComposioTools, createCreateShareTool, createCuratedMemoryTool, createDelegateTool, createDesktopPetTool, createDreamingTool, createExecCommandTool, createExecuteCodeTool, createFindTool, createGoalTool, createGrepTool, createImageGenerateTool, createImageTool, createListDirTool, createManagedJobTool, createMemoryGetTool, createMemorySearchTool, createMessageTool, createReadFileTool, createReadMediaTool, createSendMediaTool, createSessionSearchTool, createSessionStatusTool, createSkillInstallTool, createSkillManageTool, createSkillViewTool, createSkillsListTool, createSkillsMarketplaceSearchTool, createTodoTool, createToolManualTool, createUpdatePlanTool, createWebExtractTool, createWebFetchTool, createWebSearchTool, createWorkflowTool, createWriteFileTool, createXopcUseTool, findTool, formatSize, fuzzyFindText, generateDiffString, getToolMetadata, grepTool, isShareToolAvailable, listDirTool, normalizeForFuzzyMatch, normalizeToLF, resolveImageGenerationModelConfigForTool, resolveImageModelConfigForTool, resolveToolLockMode, restoreLineEndings, stripBom, stripHtmlBoilerplate, truncateHead, truncateLine, truncateTail, writeFileTool };

package/dist/src/agent/tools/managed-job-tool.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTool } from '@earendil-works/pi-agent-core';
+export declare function createManagedJobTool(workspace: string, getSessionKey: () => string | undefined, getSkillPassthroughEnvVarNames?: () => string[]): AgentTool;

package/dist/src/agent/tools/managed-job-tool.js

@@ -0,0 +1,160 @@
+import { resolveGlobalSingleton } from "../../utils/global-singleton.js";
+import { evaluateExecPolicy } from "../sandbox/exec-policy.js";
+import { resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/managed-job-tool.ts
+const MANAGED_JOB_REGISTRY_KEY = Symbol.for("xopc.managedJobRegistry");
+const DEFAULT_MAX_RUNTIME_MS = 60 * 6e4;
+const MAX_RUNTIME_MS = 1440 * 6e4;
+const MAX_CAPTURE_CHARS = 2e5;
+var ManagedJobRegistry = class {
+	jobs = /* @__PURE__ */ new Map();
+	start(owner, command, cwd, env, maxRuntimeMs) {
+		this.prune();
+		const id = randomUUID();
+		const child = spawn(command, [], {
+			shell: true,
+			cwd,
+			env,
+			detached: process.platform !== "win32"
+		});
+		const job = {
+			id,
+			owner,
+			command,
+			cwd,
+			status: "running",
+			process: child,
+			pid: child.pid,
+			createdAtMs: Date.now(),
+			stdout: "",
+			stderr: "",
+			timeout: setTimeout(() => this.stop(job, "timed_out"), maxRuntimeMs)
+		};
+		job.timeout.unref?.();
+		const append = (stream, value) => {
+			const next = `${job[stream]}${String(value)}`;
+			job[stream] = next.length > MAX_CAPTURE_CHARS ? next.slice(-MAX_CAPTURE_CHARS) : next;
+		};
+		child.stdout?.on("data", (value) => append("stdout", value));
+		child.stderr?.on("data", (value) => append("stderr", value));
+		child.on("error", (error) => append("stderr", `\n${error.message}`));
+		child.on("close", (exitCode) => {
+			if (job.status === "running") job.status = exitCode === 0 ? "succeeded" : "failed";
+			job.exitCode = exitCode;
+			job.endedAtMs = Date.now();
+			clearTimeout(job.timeout);
+		});
+		this.jobs.set(id, job);
+		return this.view(job);
+	}
+	get(owner, id) {
+		const job = this.jobs.get(id);
+		return job?.owner === owner ? this.view(job) : void 0;
+	}
+	list(owner) {
+		return [...this.jobs.values()].filter((job) => job.owner === owner).toSorted((a, b) => b.createdAtMs - a.createdAtMs).slice(0, 50).map((job) => this.view(job));
+	}
+	cancel(owner, id) {
+		const job = this.jobs.get(id);
+		if (!job || job.owner !== owner) return void 0;
+		if (job.status === "running") this.stop(job, "cancelled");
+		return this.view(job);
+	}
+	stop(job, status) {
+		if (job.status !== "running") return;
+		job.status = status;
+		job.endedAtMs = Date.now();
+		clearTimeout(job.timeout);
+		if (job.pid && process.platform !== "win32") try {
+			process.kill(-job.pid, "SIGTERM");
+			return;
+		} catch {}
+		job.process.kill("SIGTERM");
+	}
+	view(job) {
+		const outputLength = job.stdout.length + job.stderr.length;
+		return {
+			id: job.id,
+			command: job.command,
+			cwd: job.cwd,
+			status: job.status,
+			pid: job.pid,
+			createdAtMs: job.createdAtMs,
+			endedAtMs: job.endedAtMs,
+			exitCode: job.exitCode,
+			stdout: job.stdout,
+			stderr: job.stderr,
+			durationMs: (job.endedAtMs ?? Date.now()) - job.createdAtMs,
+			outputTruncated: outputLength >= MAX_CAPTURE_CHARS
+		};
+	}
+	prune() {
+		if (this.jobs.size < 500) return;
+		const removable = [...this.jobs.values()].filter((job) => job.status !== "running").toSorted((a, b) => a.createdAtMs - b.createdAtMs).slice(0, Math.max(1, this.jobs.size - 400));
+		for (const job of removable) this.jobs.delete(job.id);
+	}
+};
+const ManagedJobSchema = Type.Union([
+	Type.Object({
+		action: Type.Literal("start"),
+		command: Type.String(),
+		cwd: Type.Optional(Type.String()),
+		maxRuntimeMs: Type.Optional(Type.Number())
+	}),
+	Type.Object({
+		action: Type.Literal("status"),
+		jobId: Type.String()
+	}),
+	Type.Object({ action: Type.Literal("list") }),
+	Type.Object({
+		action: Type.Literal("cancel"),
+		jobId: Type.String()
+	})
+]);
+function registry() {
+	return resolveGlobalSingleton(MANAGED_JOB_REGISTRY_KEY, () => new ManagedJobRegistry());
+}
+function result(value) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value, null, 2)
+		}],
+		details: {}
+	};
+}
+function createManagedJobTool(workspace, getSessionKey, getSkillPassthroughEnvVarNames) {
+	return {
+		name: "managed_job",
+		label: "Managed Job",
+		description: "Start and manage commands expected to outlive a single tool call. Start returns a jobId immediately; use status/list/cancel to observe or stop it.",
+		parameters: ManagedJobSchema,
+		supportsParallel: true,
+		idempotent: false,
+		async execute(_toolCallId, input) {
+			const owner = getSessionKey() ?? "default";
+			if (input.action === "list") return result(registry().list(owner));
+			if (input.action === "status") return result(registry().get(owner, input.jobId) ?? { error: "Managed job not found" });
+			if (input.action === "cancel") return result(registry().cancel(owner, input.jobId) ?? { error: "Managed job not found" });
+			const command = String(input.command ?? "").trim();
+			if (!command) return result({ error: "command is required" });
+			const policy = evaluateExecPolicy({
+				command,
+				cwd: input.cwd?.trim() ? resolve(workspace, input.cwd.trim()) : workspace,
+				allowedEnvVars: getSkillPassthroughEnvVarNames?.() ?? []
+			});
+			if (!policy.allowed) return result({ error: `Sandbox blocked command: ${policy.reason}` });
+			const rawMax = Number(input.maxRuntimeMs ?? DEFAULT_MAX_RUNTIME_MS);
+			const maxRuntimeMs = Math.min(MAX_RUNTIME_MS, Math.max(1e3, Number.isFinite(rawMax) ? rawMax : DEFAULT_MAX_RUNTIME_MS));
+			return result(registry().start(owner, command, policy.effectiveCwd, {
+				...policy.sanitizedEnv,
+				COLUMNS: "200"
+			}, maxRuntimeMs));
+		}
+	};
+}
+//#endregion
+export { createManagedJobTool };

package/dist/src/agent/tools/todo-tool.d.ts

@@ -16,6 +16,11 @@ export declare class TodoStore {
 export interface CreateTodoToolOptions {
     /** Resolve session key for isolated lists; defaults to a single in-memory list. */
     getSessionKey?: () => string | null | undefined;
+    repository?: {
+        isAvailable?: () => boolean;
+        read: (sessionKey: string) => TodoItem[];
+        write: (sessionKey: string, items: TodoItem[]) => void;
+    };
 }
 /**
  * In-session task list for multi-step work. One {@link TodoStore} per session key.

package/dist/src/agent/tools/todo-tool.js

@@ -97,8 +97,17 @@ function resolveSessionKey(getSessionKey) {
 function createTodoTool(options) {
 	const getSessionKey = options?.getSessionKey ?? (() => "default");
 	const stores = /* @__PURE__ */ new Map();
-	const getStore = () => {
-		const key = resolveSessionKey(getSessionKey);
+	const activeRepository = () => {
+		const repository = options?.repository;
+		return repository && (repository.isAvailable?.() ?? true) ? repository : void 0;
+	};
+	const getStore = (key) => {
+		const repository = activeRepository();
+		if (repository) {
+			const store = new TodoStore();
+			store.write(repository.read(key), false);
+			return store;
+		}
 		let s = stores.get(key);
 		if (!s) {
 			s = new TodoStore();
@@ -112,8 +121,10 @@ function createTodoTool(options) {
 		description: "Plan and track tasks for complex multi-step work.\n\nUSAGE:\n- Provide `todos` array to write/update tasks\n- Omit `todos` to read the current list\n- Set `merge: true` to update existing items by id without replacing the whole list\n- Each item needs: id (unique string), content (task description), status\n- Valid statuses: pending, in_progress, completed, cancelled\n\nWHEN TO USE:\n- At the start of complex tasks (3+ steps) to plan your approach\n- After completing each step to update progress\n- When the user asks about progress or remaining work\n\nBEST PRACTICES:\n- Keep only one item in_progress at a time\n- Use merge=true to update status without rewriting the whole list\n- Create concrete, actionable items (not vague goals)",
 		parameters: TodoSchema,
 		async execute(_toolCallId, params, _signal) {
-			const store = getStore();
+			let store;
 			try {
+				const key = resolveSessionKey(getSessionKey);
+				store = getStore(key);
 				if (params.todos === void 0) {
 					const items = store.read();
 					return {
@@ -126,6 +137,7 @@ function createTodoTool(options) {
 				}
 				const p = params;
 				const items = store.write(p.todos, p.merge ?? false);
+				activeRepository()?.write(key, items);
 				return {
 					content: [{
 						type: "text",
@@ -139,7 +151,7 @@ function createTodoTool(options) {
 						type: "text",
 						text: `Error: ${error instanceof Error ? error.message : String(error)}`
 					}],
-					details: { items: store.read() }
+					details: { items: store?.read() ?? [] }
 				};
 			}
 		}

package/dist/src/agent/tools/update-plan-tool.d.ts

@@ -1,6 +1,7 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 export type TurnPlanStatus = 'pending' | 'in_progress' | 'completed';
 export interface TurnPlanStep {
+    id?: string;
     step: string;
     status: TurnPlanStatus;
 }

package/dist/src/agent/tools/update-plan-tool.js

@@ -6,6 +6,10 @@ const VALID_STATUSES = new Set([
 	"completed"
 ]);
 const PlanStepSchema = Type.Object({
+	id: Type.Optional(Type.String({
+		minLength: 1,
+		description: "Stable identifier for this step"
+	})),
 	step: Type.String({
 		minLength: 1,
 		description: "Short task step"
@@ -28,11 +32,13 @@ function normalizePlan(raw) {
 	if (!Array.isArray(raw)) throw new Error("plan must be an array");
 	const plan = raw.map((item) => {
 		const rec = item && typeof item === "object" ? item : {};
+		const id = typeof rec.id === "string" && rec.id.trim() ? rec.id.trim() : void 0;
 		const step = String(rec.step ?? "").trim();
 		const statusRaw = String(rec.status ?? "").trim();
 		if (!step) throw new Error("each plan item must include a non-empty step");
 		if (!VALID_STATUSES.has(statusRaw)) throw new Error(`invalid plan status: ${statusRaw || "(empty)"}`);
 		return {
+			...id ? { id } : {},
 			step,
 			status: statusRaw
 		};

package/dist/src/agent/workspace-runtime/registry.d.ts

@@ -34,6 +34,8 @@ export interface WorkspaceRuntimeRegistryOptions {
     bundledSkillsDir: string;
     /** Called after a runtime is first created for a workspace. */
     onRuntimeCreated?: (resolvedPath: string) => void;
+    /** Dynamic project trust lookup used by workspace compatibility skills. */
+    isWorkspaceTrusted?: (resolvedPath: string) => boolean;
 }
 export declare class WorkspaceRuntimeRegistry {
     private readonly runtimes;
@@ -41,6 +43,7 @@ export declare class WorkspaceRuntimeRegistry {
     private readonly getConfig;
     private readonly bundledSkillsDir;
     private readonly onRuntimeCreated?;
+    private readonly isWorkspaceTrusted?;
     private readonly userContextRuntimes;
     constructor(opts: WorkspaceRuntimeRegistryOptions);
     /** Lazily construct and cache an agent-scoped runtime for a workspace. */

package/dist/src/agent/workspace-runtime/registry.js

@@ -18,11 +18,13 @@ var WorkspaceRuntimeRegistry = class {
 	getConfig;
 	bundledSkillsDir;
 	onRuntimeCreated;
+	isWorkspaceTrusted;
 	userContextRuntimes = new UserContextRuntimeRegistry();
 	constructor(opts) {
 		this.getConfig = opts.getConfig;
 		this.bundledSkillsDir = opts.bundledSkillsDir;
 		this.onRuntimeCreated = opts.onRuntimeCreated;
+		this.isWorkspaceTrusted = opts.isWorkspaceTrusted;
 	}
 	/** Lazily construct and cache an agent-scoped runtime for a workspace. */
 	getOrCreate(resolvedPath, requestedAgentId) {
@@ -31,7 +33,7 @@ var WorkspaceRuntimeRegistry = class {
 		const existing = this.runtimes.get(runtimeKey);
 		if (existing) return existing;
 		const { builtinMemoryStore, memoryManager } = this.userContextRuntimes.getOrCreate(cfg);
-		const skillManager = new SkillManager(resolvedPath, this.bundledSkillsDir);
+		const skillManager = new SkillManager(resolvedPath, this.bundledSkillsDir, { isWorkspaceTrusted: () => this.isWorkspaceTrusted?.(resolvedPath) === true });
 		const rt = {
 			skillManager,
 			systemPromptBuilder: new SystemPromptBuilder({

package/dist/src/agent-runtime/index.js

@@ -1,7 +1,7 @@
-import { buildMemoryRuntime } from "./memory-runtime.js";
 import { checkBoundary } from "./boundary-guard.js";
 import { resolveModelRole } from "./model-router.js";
 import { buildRuntimeToolRegistry } from "./tool-registry.js";
+import { buildMemoryRuntime } from "./memory-runtime.js";
 import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
 import { buildAgentRuntimeProfile } from "./runtime-profile.js";
 import { appendAgentRunEvent, createAgentRunTrace, finishAgentRunTrace, hashEffectiveManifest } from "./run-trace.js";

package/dist/src/agent-runtime/runtime-profile.js

@@ -1,9 +1,9 @@
 import { buildAgentManifestPromptSection } from "../agent-manifest/prompt.js";
 import "../agent-manifest/index.js";
-import { buildMemoryRuntime } from "./memory-runtime.js";
 import { checkBoundary } from "./boundary-guard.js";
 import { resolveModelRole } from "./model-router.js";
 import { buildRuntimeToolRegistry } from "./tool-registry.js";
+import { buildMemoryRuntime } from "./memory-runtime.js";
 import { resolveWorkflow, validateWorkflowForRuntime } from "./workflow-runtime.js";
 //#region src/agent-runtime/runtime-profile.ts
 function buildAgentRuntimeProfile(params) {

package/dist/src/auth/credentials.d.ts

@@ -1,4 +1,5 @@
 import type { Config } from '../config/schema.js';
+import type { OAuthCredentials } from './oauth/types.js';
 export type CredentialType = 'api_key' | 'oauth';
 export interface ApiKeyProfile {
     type: 'api_key';
@@ -17,6 +18,7 @@ export interface OAuthToken {
     createdAt: string;
     updatedAt: string;
 }
+type OAuthTokenInput = Omit<OAuthToken, 'type' | 'provider' | 'updatedAt'> & Record<string, unknown>;
 export type CredentialProfile = ApiKeyProfile;
 export interface AuthProfilesFile {
     version: number;
@@ -77,6 +79,7 @@ export declare class CredentialResolver {
      * Load OAuth token for a provider.
      */
     loadOAuthToken(provider: string): Promise<OAuthToken | null>;
+    private hasUsableOAuthTokenRecord;
     /**
      * Load the raw OAuth token record, including expired tokens for status UIs.
      */
@@ -88,10 +91,14 @@ export declare class CredentialResolver {
         hasAccess: boolean;
         hasRefresh: boolean;
     }>>;
+    /**
+     * Save raw provider OAuth credentials without converting them to an API key representation.
+     */
+    saveOAuthCredentials(provider: string, credentials: OAuthCredentials): Promise<void>;
     /**
      * Save OAuth token for a provider.
      */
-    saveOAuthToken(provider: string, token: Omit<OAuthToken, 'type' | 'provider' | 'updatedAt'>): Promise<void>;
+    saveOAuthToken(provider: string, token: OAuthTokenInput): Promise<void>;
     /**
      * Delete the OAuth token persisted for a provider.
      */
@@ -114,3 +121,4 @@ export declare class CredentialResolver {
 export declare function getCredentialResolver(options?: CredentialResolverOptions): CredentialResolver;
 export declare function resolveApiKey(provider: string, options?: CredentialResolverOptions): Promise<string | null>;
 export declare function hasCredentials(provider: string, options?: CredentialResolverOptions): Promise<boolean>;
+export {};

package/dist/src/auth/credentials.js

@@ -1,13 +1,41 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { init_paths, resolveAgentAuthProfilesPath, resolveAuthProfilesPath, resolveCredentialsDir, resolveOAuthPath } from "../config/paths.js";
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
-import { getOAuthProviderDefinition, init_registry } from "./oauth/registry.js";
+import { init_paths, resolveAgentAuthProfilesPath, resolveAuthProfilesPath, resolveCredentialsDir, resolveOAuthPath } from "../config/paths.js";
 import { getApiKeyFromEnv, init_env_keys } from "../providers/env-keys.js";
+import { getOAuthProviderDefinition, init_registry } from "./oauth/registry.js";
+import { init_oauth_provider_lock, withOAuthProviderLock } from "./oauth-provider-lock.js";
 import { dirname, join } from "path";
 import { mkdir, readFile, readdir, rm } from "fs/promises";
 //#region src/auth/credentials.ts
+function toOAuthCredentials(token) {
+	const { type: _type, provider: _provider, expiresAt, createdAt: _createdAt, updatedAt: _updatedAt, ...providerFields } = token;
+	return {
+		...providerFields,
+		access: token.access,
+		refresh: token.refresh ?? "",
+		expires: expiresAt ?? Number.MAX_SAFE_INTEGER
+	};
+}
+function normalizeLegacyOAuthToken(token) {
+	if (token.provider !== "google-gemini-cli" && token.provider !== "google-antigravity") return token;
+	let access = token.access;
+	let projectId = token.projectId;
+	for (let depth = 0; depth < 5; depth += 1) try {
+		const legacy = JSON.parse(access);
+		if (typeof legacy.token !== "string" || !legacy.token) break;
+		access = legacy.token;
+		if (typeof projectId !== "string" && typeof legacy.projectId === "string") projectId = legacy.projectId;
+	} catch {
+		break;
+	}
+	return access === token.access ? token : {
+		...token,
+		access,
+		projectId
+	};
+}
 function getCredentialResolver(options) {
 	if (options) return new CredentialResolver(options);
 	defaultResolver ??= new CredentialResolver();
@@ -19,16 +47,16 @@ async function resolveApiKey(provider, options) {
 async function hasCredentials(provider, options) {
 	return getCredentialResolver(options).hasCredentials(provider);
 }
-var log, warnedExpiredOAuthTokens, oauthRefreshes, CredentialResolver, defaultResolver;
+var log, warnedExpiredOAuthTokens, CredentialResolver, defaultResolver;
 var init_credentials = __esmMin((() => {
 	init_write_file_atomic();
 	init_logger();
 	init_env_keys();
 	init_paths();
 	init_registry();
+	init_oauth_provider_lock();
 	log = createLogger("Credentials");
 	warnedExpiredOAuthTokens = /* @__PURE__ */ new Set();
-	oauthRefreshes = /* @__PURE__ */ new Map();
 	CredentialResolver = class {
 		credentialsDir;
 		agentId;
@@ -45,7 +73,11 @@ var init_credentials = __esmMin((() => {
 		*/
 		async resolveApiKey(provider) {
 			const normalizedProvider = provider.toLowerCase();
-			if (getOAuthProviderDefinition(normalizedProvider)?.oauthOnly) return (await this.loadOAuthToken(normalizedProvider))?.access ?? null;
+			const oauthDefinition = getOAuthProviderDefinition(normalizedProvider);
+			if (oauthDefinition?.oauthOnly) {
+				const token = await this.loadOAuthToken(normalizedProvider);
+				return token ? oauthDefinition.provider.getApiKey(toOAuthCredentials(token)) : null;
+			}
 			if (this.agentId) {
 				const agentKey = await this.loadFromAgentCredentials(normalizedProvider);
 				if (agentKey) {
@@ -70,7 +102,7 @@ var init_credentials = __esmMin((() => {
 					provider,
 					source: "oauth"
 				}, "Resolved API key from OAuth token");
-				return oauthToken.access;
+				return oauthDefinition ? oauthDefinition.provider.getApiKey(toOAuthCredentials(oauthToken)) : oauthToken.access;
 			}
 			const envKey = getApiKeyFromEnv(normalizedProvider);
 			if (envKey) {
@@ -86,19 +118,19 @@ var init_credentials = __esmMin((() => {
 		* Check if a provider has credentials configured
 		*/
 		async hasCredentials(provider) {
-			return await this.resolveApiKey(provider) !== null;
+			return await this.resolveApiKeySource(provider) !== null;
 		}
 		/**
 		* Which step in {@link resolveApiKey} would supply the key (no secret material).
 		*/
 		async resolveApiKeySource(provider) {
 			const normalizedProvider = provider.toLowerCase();
-			if (getOAuthProviderDefinition(normalizedProvider)?.oauthOnly) return await this.loadOAuthToken(normalizedProvider) ? "oauth" : null;
+			if (getOAuthProviderDefinition(normalizedProvider)?.oauthOnly) return await this.hasUsableOAuthTokenRecord(normalizedProvider) ? "oauth" : null;
 			if (this.agentId) {
 				if (await this.loadFromAgentCredentials(normalizedProvider)) return "agent";
 			}
 			if (await this.loadFromGlobalCredentials(normalizedProvider)) return "global";
-			if (await this.loadOAuthToken(normalizedProvider)) return "oauth";
+			if (await this.hasUsableOAuthTokenRecord(normalizedProvider)) return "oauth";
 			if (getApiKeyFromEnv(normalizedProvider)) return "env";
 			return null;
 		}
@@ -169,42 +201,42 @@ var init_credentials = __esmMin((() => {
 		* Load OAuth token for a provider.
 		*/
 		async loadOAuthToken(provider) {
-			const token = await this.loadOAuthTokenRecord(provider);
+			const normalizedProvider = provider.toLowerCase();
+			let token = await this.loadOAuthTokenRecord(normalizedProvider);
 			if (!token) return null;
-			const expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
+			let expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
 			if (expiresAt <= Date.now() + 6e4 && token.refresh) {
-				const definition = getOAuthProviderDefinition(provider);
-				if (definition) {
-					let pending = oauthRefreshes.get(provider);
-					if (!pending) {
-						pending = definition.provider.refreshToken({
-							access: token.access,
-							refresh: token.refresh,
-							expires: expiresAt
-						}).then(async (refreshed) => {
-							const updated = {
-								...token,
-								access: definition.provider.getApiKey(refreshed),
-								refresh: refreshed.refresh,
-								expiresAt: refreshed.expires,
-								scope: Array.isArray(refreshed.scope) ? refreshed.scope.filter((value) => typeof value === "string") : token.scope,
-								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-							};
-							await this.saveOAuthToken(provider, updated);
-							return updated;
-						}).finally(() => oauthRefreshes.delete(provider));
-						oauthRefreshes.set(provider, pending);
-					}
-					try {
-						return await pending;
-					} catch (err) {
-						if (expiresAt > Date.now()) {
-							log.warn({
-								err,
-								provider
-							}, "OAuth refresh failed; using the current access token");
-							return token;
-						}
+				const definition = getOAuthProviderDefinition(normalizedProvider);
+				if (definition) try {
+					token = await withOAuthProviderLock(normalizedProvider, async () => {
+						const current = await this.loadOAuthTokenRecord(normalizedProvider);
+						if (!current) return null;
+						if ((current.expiresAt ?? Number.POSITIVE_INFINITY) > Date.now() + 6e4 || !current.refresh) return current;
+						const refreshed = await definition.provider.refreshToken(toOAuthCredentials(current));
+						const { expires, ...refreshedFields } = refreshed;
+						const updated = {
+							...current,
+							...refreshedFields,
+							access: refreshed.access,
+							refresh: refreshed.refresh,
+							expiresAt: expires,
+							scope: Array.isArray(refreshed.scope) ? refreshed.scope.filter((value) => typeof value === "string") : current.scope,
+							updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+						};
+						await this.saveOAuthToken(normalizedProvider, updated);
+						return updated;
+					});
+					if (!token) return null;
+					expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
+				} catch (err) {
+					token = await this.loadOAuthTokenRecord(normalizedProvider) ?? token;
+					expiresAt = token.expiresAt ?? Number.POSITIVE_INFINITY;
+					if (expiresAt > Date.now()) {
+						log.warn({
+							err,
+							provider: normalizedProvider
+						}, "OAuth refresh failed; using the current access token");
+						return token;
 					}
 				}
 			}
@@ -221,6 +253,12 @@ var init_credentials = __esmMin((() => {
 			}
 			return token;
 		}
+		async hasUsableOAuthTokenRecord(provider) {
+			const token = await this.loadOAuthTokenRecord(provider);
+			if (!token?.access?.trim()) return null;
+			if (token.expiresAt && token.expiresAt <= Date.now() && !token.refresh?.trim()) return null;
+			return token;
+		}
 		/**
 		* Load the raw OAuth token record, including expired tokens for status UIs.
 		*/
@@ -230,7 +268,7 @@ var init_credentials = __esmMin((() => {
 			try {
 				const content = await readFile(oauthPath, "utf-8");
 				const token = JSON.parse(content);
-				return token.provider === normalizedProvider ? token : null;
+				return token.provider === normalizedProvider ? normalizeLegacyOAuthToken(token) : null;
 			} catch {
 				return null;
 			}
@@ -266,28 +304,46 @@ var init_credentials = __esmMin((() => {
 			return tokens.sort((a, b) => a.provider.localeCompare(b.provider));
 		}
 		/**
+		* Save raw provider OAuth credentials without converting them to an API key representation.
+		*/
+		async saveOAuthCredentials(provider, credentials) {
+			const { access, refresh, expires, scope, ...providerFields } = credentials;
+			await this.saveOAuthToken(provider, {
+				...providerFields,
+				access,
+				refresh,
+				expiresAt: expires,
+				scope: Array.isArray(scope) ? scope.filter((value) => typeof value === "string") : void 0,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		/**
 		* Save OAuth token for a provider.
 		*/
 		async saveOAuthToken(provider, token) {
 			const normalizedProvider = provider.toLowerCase();
-			const oauthPath = resolveOAuthPath(normalizedProvider);
-			await mkdir(dirname(oauthPath), { recursive: true });
-			const fullToken = {
-				...token,
-				type: "oauth",
-				provider: normalizedProvider,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			await writeTextAtomic(oauthPath, JSON.stringify(fullToken, null, 2));
-			log.info({ provider: normalizedProvider }, "Saved OAuth token");
+			await withOAuthProviderLock(normalizedProvider, async () => {
+				const oauthPath = resolveOAuthPath(normalizedProvider);
+				await mkdir(dirname(oauthPath), { recursive: true });
+				const fullToken = {
+					...token,
+					type: "oauth",
+					provider: normalizedProvider,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				await writeTextAtomic(oauthPath, JSON.stringify(fullToken, null, 2));
+				log.info({ provider: normalizedProvider }, "Saved OAuth token");
+			});
 		}
 		/**
 		* Delete the OAuth token persisted for a provider.
 		*/
 		async deleteOAuthToken(provider) {
 			const normalizedProvider = provider.toLowerCase();
-			await rm(resolveOAuthPath(normalizedProvider), { force: true });
-			log.info({ provider: normalizedProvider }, "Deleted OAuth token");
+			await withOAuthProviderLock(normalizedProvider, async () => {
+				await rm(resolveOAuthPath(normalizedProvider), { force: true });
+				log.info({ provider: normalizedProvider }, "Deleted OAuth token");
+			});
 		}
 		/**
 		* Disconnect the default credential for a provider from local storage.