@oh-my-pi/pi-coding-agent 17.0.2 → 17.0.3

package/src/eval/jl/prelude.jl

@@ -519,7 +519,7 @@ function completion(prompt::String; model="default", system=nothing, schema=noth
     return schema === nothing ? text : Main.json_parse(string(text))
 end
 
-function agent(prompt::String; agent="task", model=nothing, label=nothing, schema=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
+function agent(prompt::String; agent="task", model=nothing, label=nothing, schema=nothing, schema_mode=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
     args_dict = Dict{String, Any}("prompt" => prompt)
     if agent !== nothing
         args_dict["agent"] = agent
@@ -533,8 +533,9 @@ function agent(prompt::String; agent="task", model=nothing, label=nothing, schem
     if schema !== nothing
         args_dict["schema"] = schema
     end
-    # Isolation knobs mirror the `task` tool: strict opt-in via `isolated`,
-    # with `apply`/`merge` controlling the post-run patch/branch merge.
+    if schema_mode !== nothing
+        args_dict["schemaMode"] = schema_mode
+    end
     if isolated !== nothing
         args_dict["isolated"] = Bool(isolated)
     end
@@ -548,13 +549,13 @@ function agent(prompt::String; agent="task", model=nothing, label=nothing, schem
     for (k, v) in kwargs
         args_dict[string(k)] = v
     end
-    # Tell the bridge a handle is wanted so it preserves the backing artifacts.
     if handle_result
         args_dict["handle"] = true
     end
     res = __omp_call_bridge("__agent__", args_dict)
     text = res isa AbstractDict ? get(res, "text", res) : res
-    parsed = schema === nothing ? text : Main.json_parse(string(text))
+    has_data = res isa AbstractDict && haskey(res, "data")
+    parsed = has_data ? res["data"] : (schema === nothing ? text : Main.json_parse(string(text)))
     if !handle_result
         return parsed
     end
@@ -569,7 +570,7 @@ function agent(prompt::String; agent="task", model=nothing, label=nothing, schem
         "id" => get(details, "id", nothing),
         "agent" => get(details, "agent", nothing)
     )
-    if schema !== nothing
+    if has_data || schema !== nothing
         node["data"] = parsed
     end
     for (src_key, dst_key) in (

package/src/eval/js/shared/prelude.txt

@@ -104,20 +104,21 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 			"agent",
 			opts,
 			rest,
-			["agent", "model", "label", "schema", "isolated", "apply", "merge"],
-			"{ agent, model, label, schema, isolated, apply, merge, handle }",
+			["agent", "model", "label", "schema", "isolated", "apply", "merge", "schemaMode"],
+			"{ agent, model, label, schema, isolated, apply, merge, schemaMode, handle }",
 		);
 		const { handle, ...callArgs } = o;
 		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...callArgs, handle: Boolean(handle) });
 		const text = res && typeof res === "object" ? res.text : res;
-		const parsed = hasOwn(callArgs, "schema") ? JSON.parse(text) : text;
+		const hasData = res && typeof res === "object" && hasOwn(res, "data");
+		const parsed = hasData ? res.data : hasOwn(callArgs, "schema") ? JSON.parse(text) : text;
 		if (!handle) return parsed;
 		const details = res && typeof res === "object" ? res.details : undefined;
 		if (!details || typeof details !== "object" || details.id == null) {
 			return { text, output: text, handle: null, id: null, agent: null };
 		}
 		const node = { text, output: text, handle: `agent://${details.id}`, id: details.id, agent: details.agent ?? null };
-		if (hasOwn(callArgs, "schema")) node.data = parsed;
+		if (hasData || hasOwn(callArgs, "schema")) node.data = parsed;
 		for (const key of ["isolated", "patchPath", "branchName", "nestedPatches", "changesApplied", "isolationSummary"]) {
 			if (details[key] !== undefined) node[key] = details[key];
 		}

package/src/eval/py/prelude.py

@@ -487,48 +487,17 @@ if "__omp_prelude_loaded__" not in globals():
         model=None,
         label=None,
         schema=None,
+        schema_mode=None,
         isolated=None,
         apply=None,
         merge=None,
         handle=False,
     ):
-        """Run a subagent and return its final output.
-
-        `agent` selects the subagent definition (default "task"). Pass
-        `model` to override that agent's model, `label` for the output artifact
-        id, and `schema` to request structured JSON output; when `schema` is
-        supplied the parsed object is returned. Share background by writing a
-        local:// file and referencing it in the prompt.
-
-        Pass `isolated=True` to run the subagent inside an isolation worktree
-        (copy-on-write of the parent repo) so parallel `agent()` spawns can
-        edit overlapping files safely. Strict opt-in, mirroring the `task`
-        tool: the default is non-isolated regardless of `task.isolation.mode`.
-        `isolated=True` while the setting is `"none"` errors out instead of
-        silently downgrading.
-
-        When isolated, `apply=False` keeps captured changes inside the
-        worktree and surfaces the root patch path, branch name, and nested
-        repository patches through the DAG node dict (combine with
-        `handle=True` to receive them — see below; the bare return type
-        stays bytes/string/parsed object and has nowhere to expose artifacts).
-        `merge=False` forces patch mode even when `task.isolation.merge` is
-        `"branch"`, avoiding the per-call git lock + repo mutation that branch
-        mode performs.
-
-        Set `handle=True` to receive a DAG node dict instead of bare
-        text: ``{"text", "output", "handle", "id", "agent"}`` where ``handle``
-        is the spawned agent's recoverable ``agent://<id>`` URI. A downstream
-        ``pipeline``/``parallel`` stage embeds that ``handle`` (or ``output``)
-        in its prompt so a large transcript flows through the graph by
-        reference, never re-inlined. When ``schema`` is also set the parsed
-        object lands under ``"data"``. When the spawn ran isolated the node
-        also carries ``"isolated"`` and, when present, ``"patch_path"``,
-        ``"branch_name"``, ``"nested_patches"``, ``"changes_applied"``
-        (``True``/``False``/``None`` — ``None`` means ``apply=False``), and
-        ``"isolation_summary"``. If
-        the bridge returns no recoverable id the node still resolves with
-        ``handle=None`` — the helper never throws.
+        """Run a subagent and return its final output or structured data.
+
+        `schema` overrides agent and session schemas. `schema_mode` is
+        `"permissive"` or `"strict"`. `handle=True` returns the child output
+        reference and metadata, with parsed data under `"data"` when available.
         """
         args = {"prompt": prompt}
         if agent is not None:
@@ -539,6 +508,8 @@ if "__omp_prelude_loaded__" not in globals():
             args["label"] = label
         if schema is not None:
             args["schema"] = schema
+        if schema_mode is not None:
+            args["schemaMode"] = schema_mode
         if isolated is not None:
             args["isolated"] = bool(isolated)
         if apply is not None:
@@ -549,7 +520,8 @@ if "__omp_prelude_loaded__" not in globals():
             args["handle"] = True
         res = _bridge_call("__agent__", args)
         text = res.get("text") if isinstance(res, dict) else res
-        parsed = json.loads(text) if schema is not None else text
+        has_data = isinstance(res, dict) and "data" in res
+        parsed = res["data"] if has_data else json.loads(text) if schema is not None else text
         if not handle:
             return parsed
         details = res.get("details") if isinstance(res, dict) else None
@@ -568,7 +540,7 @@ if "__omp_prelude_loaded__" not in globals():
             "id": details["id"],
             "agent": details.get("agent"),
         }
-        if schema is not None:
+        if has_data or schema is not None:
             node["data"] = parsed
         for src_key, dst_key in (
             ("isolated", "isolated"),

package/src/eval/rb/prelude.rb

@@ -392,22 +392,21 @@ unless defined?($__omp_prelude_loaded) && $__omp_prelude_loaded
     schema.nil? ? text : JSON.parse(text)
   end
 
-  def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated: nil, apply: nil, merge: nil, handle: false)
+  def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, schema_mode: nil, isolated: nil, apply: nil, merge: nil, handle: false)
     args = { "prompt" => prompt }
     args["agent"] = agent unless agent.nil?
     args["model"] = model unless model.nil?
     args["label"] = label unless label.nil?
     args["schema"] = schema unless schema.nil?
-    # Isolation knobs mirror the `task` tool: strict opt-in via `isolated`,
-    # with `apply`/`merge` controlling the post-run patch/branch merge.
+    args["schemaMode"] = schema_mode unless schema_mode.nil?
     args["isolated"] = !!isolated unless isolated.nil?
     args["apply"] = !!apply unless apply.nil?
     args["merge"] = !!merge unless merge.nil?
-    # Tell the bridge a handle is wanted so it preserves the backing artifacts.
     args["handle"] = true if handle
     res = OmpBridge.call("__agent__", args)
     text = res.is_a?(Hash) ? res["text"] : res
-    parsed = schema.nil? ? text : JSON.parse(text)
+    has_data = res.is_a?(Hash) && res.key?("data")
+    parsed = has_data ? res["data"] : (schema.nil? ? text : JSON.parse(text))
     return parsed unless handle
     details = res.is_a?(Hash) ? res["details"] : nil
     if !details.is_a?(Hash) || details["id"].nil?
@@ -420,7 +419,7 @@ unless defined?($__omp_prelude_loaded) && $__omp_prelude_loaded
       "id" => details["id"],
       "agent" => details["agent"],
     }
-    node["data"] = parsed unless schema.nil?
+    node["data"] = parsed if has_data || !schema.nil?
     {
       "isolated" => "isolated",
       "patchPath" => "patch_path",

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -12,12 +12,18 @@
  * the same module identity as a direct `@oh-my-pi/pi-coding-agent` import.
  */
 
-import * as fs from "node:fs/promises";
+import { Database } from "bun:sqlite";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { TSchema } from "@oh-my-pi/pi-ai";
+import { type AuthCredential, SqliteAuthCredentialStore, type TSchema } from "@oh-my-pi/pi-ai";
 import { Text } from "@oh-my-pi/pi-tui";
-import { getAgentDir, getProjectDir, parseFrontmatter as parseOmpFrontmatter } from "@oh-my-pi/pi-utils";
+import {
+	getAgentDbPath,
+	getAgentDir,
+	getProjectDir,
+	parseFrontmatter as parseOmpFrontmatter,
+} from "@oh-my-pi/pi-utils";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { type SettingPath, Settings } from "../config/settings";
 import { EditTool } from "../edit";
@@ -606,16 +612,16 @@ export function createLsToolDefinition(cwd: string, options?: LsToolOptions): To
 			const ops = options?.operations;
 			const exists = ops
 				? await ops.exists(absolutePath)
-				: await fs.stat(absolutePath).then(
+				: await fs.promises.stat(absolutePath).then(
 						() => true,
 						() => false,
 					);
 			if (!exists) throw new Error(`Path not found: ${absolutePath}`);
-			const stat = ops ? await ops.stat(absolutePath) : await fs.stat(absolutePath);
+			const stat = ops ? await ops.stat(absolutePath) : await fs.promises.stat(absolutePath);
 			if (!stat.isDirectory()) {
 				return { content: [{ type: "text", text: rawPath }] };
 			}
-			const entries = ops ? await ops.readdir(absolutePath) : await fs.readdir(absolutePath);
+			const entries = ops ? await ops.readdir(absolutePath) : await fs.promises.readdir(absolutePath);
 			const sorted = [...entries].sort((a, b) => a.localeCompare(b));
 			const limited = sorted.slice(0, limit);
 			const output = limited.join("\n");
@@ -1100,7 +1106,7 @@ export class DefaultResourceLoader implements ResourceLoader {
 				: path.resolve(this.#state.cwd, resourcePath);
 			const files: string[] = [];
 			try {
-				const stat = await fs.stat(resolvedPath);
+				const stat = await fs.promises.stat(resolvedPath);
 				if (stat.isDirectory()) {
 					const glob = new Bun.Glob("**/*.md");
 					for await (const entry of glob.scan({ cwd: resolvedPath, absolute: false, onlyFiles: true })) {
@@ -1288,6 +1294,46 @@ export async function createAgentSession(
 	return ompCreateAgentSession(forwarded);
 }
 
+/**
+ * Synchronous auth storage surface retained for legacy extensions.
+ *
+ * Modern OMP auth storage is asynchronous, while older provider extensions
+ * call `AuthStorage.create().get()` during module initialization.
+ */
+export class AuthStorage {
+	constructor() {
+		fs.mkdirSync(path.dirname(getAgentDbPath()), { recursive: true, mode: 0o700 });
+	}
+
+	static create(): AuthStorage {
+		return new AuthStorage();
+	}
+
+	get(provider: string): AuthCredential | undefined {
+		const store = new SqliteAuthCredentialStore(new Database(getAgentDbPath()));
+		try {
+			return store.listAuthCredentials(provider)[0]?.credential;
+		} finally {
+			store.close();
+		}
+	}
+
+	set(provider: string, credential: AuthCredential): void {
+		const store = new SqliteAuthCredentialStore(new Database(getAgentDbPath()));
+		try {
+			store.upsertAuthCredentialForProvider(provider, credential);
+		} finally {
+			store.close();
+		}
+	}
+}
+
+/** Read the first active credential for a legacy extension provider. */
+export function readStoredCredential(provider: string): AuthCredential | undefined {
+	const storage = AuthStorage.create();
+	return storage.get(provider);
+}
+
 export * from "../index";
 export { formatBytes as formatSize } from "../tools/render-utils";
 export { Type } from "./typebox";

package/src/lsp/client.ts

@@ -142,6 +142,9 @@ const CLIENT_CAPABILITIES = {
 			codeDescriptionSupport: true,
 			dataSupport: true,
 		},
+		diagnostic: {
+			dynamicRegistration: true,
+		},
 	},
 	window: {
 		workDoneProgress: true,
@@ -456,6 +459,58 @@ async function handleApplyEditRequest(client: LspClient, message: LspJsonRpcRequ
 	}
 }
 
+interface DynamicCapabilityRegistration {
+	id?: unknown;
+	method?: unknown;
+}
+
+interface DynamicCapabilityParams {
+	registrations?: DynamicCapabilityRegistration[];
+	unregisterations?: DynamicCapabilityRegistration[];
+	unregistrations?: DynamicCapabilityRegistration[];
+}
+
+function updateDynamicCapabilities(client: LspClient, message: LspJsonRpcRequest): void {
+	const params = message.params as DynamicCapabilityParams;
+	if (message.method === "client/registerCapability") {
+		if (!Array.isArray(params.registrations)) return;
+		let registrations = client.dynamicCapabilityRegistrations;
+		if (!registrations) {
+			registrations = new Map();
+			client.dynamicCapabilityRegistrations = registrations;
+		}
+		for (const registration of params.registrations) {
+			if (typeof registration.id === "string" && typeof registration.method === "string") {
+				registrations.set(registration.id, registration.method);
+			}
+		}
+		return;
+	}
+
+	const registrations = client.dynamicCapabilityRegistrations;
+	if (!registrations) return;
+	const unregistrations = params.unregisterations ?? params.unregistrations;
+	if (!Array.isArray(unregistrations)) return;
+	for (const registration of unregistrations) {
+		if (typeof registration.id === "string") {
+			registrations.delete(registration.id);
+		}
+	}
+}
+
+/** Whether the server advertised LSP 3.17 document diagnostic pulls statically or through registration. */
+export function supportsDocumentDiagnostics(client: LspClient): boolean {
+	const staticProvider = client.serverCapabilities?.diagnosticProvider;
+	if (staticProvider) return true;
+
+	const registrations = client.dynamicCapabilityRegistrations;
+	if (!registrations) return false;
+	for (const method of registrations.values()) {
+		if (method === "textDocument/diagnostic") return true;
+	}
+	return false;
+}
+
 /**
  * Respond to a server-initiated request.
  */
@@ -478,6 +533,7 @@ async function handleServerRequest(client: LspClient, message: LspJsonRpcRequest
 		return;
 	}
 	if (message.method === "client/registerCapability" || message.method === "client/unregisterCapability") {
+		updateDynamicCapabilities(client, message);
 		// Some servers block semantic requests until dynamic registration succeeds.
 		await sendResponse(client, message.id, null, message.method);
 		return;
@@ -685,6 +741,7 @@ export async function getOrCreateClient(
 			requestId: 0,
 			diagnostics: new Map(),
 			diagnosticsVersion: 0,
+			dynamicCapabilityRegistrations: new Map(),
 			openFiles: new Map(),
 			pendingRequests: new Map(),
 			messageBuffer: new Uint8Array(0),

package/src/lsp/index.ts

@@ -28,6 +28,7 @@ import {
 	sendNotification,
 	sendRequest,
 	setIdleTimeout,
+	supportsDocumentDiagnostics,
 	syncContent,
 	WARMUP_TIMEOUT_MS,
 	waitForProjectLoaded,
@@ -530,17 +531,49 @@ interface WaitForDiagnosticsOptions {
 	settleMs?: number;
 }
 
+function requestDocumentDiagnostics(
+	client: LspClient,
+	uri: string,
+	signal: AbortSignal | undefined,
+	timeoutMs: number,
+): Promise<Diagnostic[] | undefined> {
+	return sendRequest(client, "textDocument/diagnostic", { textDocument: { uri } }, signal, timeoutMs)
+		.then(report => {
+			if (!report || typeof report !== "object" || !("kind" in report) || report.kind !== "full") {
+				return undefined;
+			}
+			if (!("items" in report) || !Array.isArray(report.items)) return undefined;
+			return report.items;
+		})
+		.catch(err => {
+			if (!signal?.aborted) {
+				logger.debug("LSP document diagnostic pull failed", { server: client.name, uri, error: String(err) });
+			}
+			return undefined;
+		});
+}
+
 async function waitForDiagnostics(
 	client: LspClient,
 	uri: string,
 	options: WaitForDiagnosticsOptions = {},
 ): Promise<Diagnostic[]> {
 	const { timeoutMs = 3000, signal, minVersion, expectedDocumentVersion, settleMs = DIAGNOSTICS_SETTLE_MS } = options;
-	const start = Date.now();
+	const deadline = Date.now() + timeoutMs;
+	let pullAttempted = false;
+	let pullResultPromise: Promise<{ diagnostics: Diagnostic[] | undefined }> | undefined;
+	let pulled: Diagnostic[] | undefined;
 	let settledRef: PublishedDiagnostics | undefined;
 	let settledAt = 0;
-	while (Date.now() - start < timeoutMs) {
+	while (Date.now() < deadline) {
 		throwIfAborted(signal);
+		if (!pullAttempted && supportsDocumentDiagnostics(client)) {
+			pullAttempted = true;
+			pullResultPromise = requestDocumentDiagnostics(client, uri, signal, Math.max(1, deadline - Date.now())).then(
+				diagnostics => ({ diagnostics }),
+			);
+		}
+
 		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
 		const published = client.diagnostics.get(uri);
 		if (published && versionOk) {
@@ -557,13 +590,36 @@ async function waitForDiagnostics(
 				return published.diagnostics;
 			}
 		}
-		await Bun.sleep(DIAGNOSTICS_POLL_MS);
+
+		const pollMs = Math.min(DIAGNOSTICS_POLL_MS, Math.max(0, deadline - Date.now()));
+		if (!pullResultPromise) {
+			await Bun.sleep(pollMs);
+			continue;
+		}
+		const pullResult = await Promise.race([pullResultPromise, Bun.sleep(pollMs).then(() => undefined)]);
+		if (pullResult) {
+			pullResultPromise = undefined;
+			pulled = pullResult.diagnostics;
+			if (pulled !== undefined) break;
+		}
 	}
+
 	const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
-	if (!versionOk) {
-		return [];
+	const published = client.diagnostics.get(uri);
+	if (published && versionOk) {
+		return published.diagnostics;
+	}
+	if (pullResultPromise) {
+		pulled = (await pullResultPromise).diagnostics;
 	}
-	return client.diagnostics.get(uri)?.diagnostics ?? [];
+	throwIfAborted(signal);
+	if (pulled === undefined) return [];
+	client.diagnostics.set(uri, {
+		diagnostics: pulled,
+		version: expectedDocumentVersion ?? client.openFiles.get(uri)?.version ?? null,
+	});
+	client.diagnosticsVersion += 1;
+	return pulled;
 }
 
 /** Project type detection result */

package/src/lsp/types.ts

@@ -387,6 +387,7 @@ export interface LspServerCapabilities {
 	referencesProvider?: boolean;
 	documentSymbolProvider?: boolean;
 	workspaceSymbolProvider?: boolean;
+	diagnosticProvider?: boolean | Record<string, unknown>;
 	[key: string]: unknown;
 }
 
@@ -398,6 +399,8 @@ export interface LspClient {
 	requestId: number;
 	diagnostics: Map<string, PublishedDiagnostics>;
 	diagnosticsVersion: number;
+	/** Dynamic capability registrations keyed by the server-provided registration ID. */
+	dynamicCapabilityRegistrations?: Map<string, string>;
 	openFiles: Map<string, OpenFile>;
 	pendingRequests: Map<number | string, PendingRequest>;
 	messageBuffer: Uint8Array;

package/src/mcp/oauth-flow.ts

@@ -385,6 +385,13 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 	async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> {
 		if (!this.#resolvedClientId) {
 			await this.#tryRegisterClient(redirectUri);
+			// `unapproved_client` explicitly establishes that registration cannot
+			// produce the required client id. Other DCR failures stay on the
+			// clientless probe path because they may be transient or caused by
+			// unrelated registration metadata.
+			if (!this.#resolvedClientId && this.#isDefinitiveRegistrationRejection()) {
+				throw this.#missingClientIdError();
+			}
 		}
 
 		const authUrl = new URL(this.config.authorizationUrl);
@@ -691,6 +698,19 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		}
 	}
 
+	/**
+	 * Whether the provider explicitly rejected this client as unapproved.
+	 *
+	 * HTTP status alone is insufficient: payload errors such as
+	 * `invalid_client_metadata` and `invalid_redirect_uri` do not establish that
+	 * the authorization endpoint requires a client id. Keep those on the
+	 * clientless probe path.
+	 */
+	#isDefinitiveRegistrationRejection(): boolean {
+		const failure = this.#registrationFailure;
+		return failure?.status === 403 && /\bunapproved_client\b/i.test(failure.detail ?? "");
+	}
+
 	/**
 	 * Build the error thrown when the authorize probe confirms the provider
 	 * demands a `client_id`. When dynamic client registration was attempted and