@oh-my-pi/pi-agent-core 16.1.23 → 16.2.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [16.2.0] - 2026-06-27
+
+### Added
+
+- Added an optional `cwdResolver` to `Agent` and `getCwd` to `AgentLoopConfig` to dynamically resolve the working directory per LLM call, allowing workspace-scoped provider discovery (such as GitLab Duo Agent) to follow live directory changes without reconstructing the agent.
+
+### Fixed
+
+- Fixed an issue where API-level provider refusals were replayed as assistant dialogue on subsequent requests, preventing repeated refusals after a single blocked turn.
+- Fixed a bug where internal streaming state (`partialJson`) could leak onto the final `AssistantMessage` if a stream ended without a `toolcall_end` event.
+- Fixed `Agent` to correctly forward the working directory (`cwd`) into provider stream options, enabling providers like GitLab Duo Agent to scope local tool execution to the workspace.
+- Enabled custom OpenAI-compatible providers to use native remote compaction instead of falling back to local summarization.
+
 ## [16.1.23] - 2026-06-26
 
 ### Changed

package/dist/types/agent.d.ts

@@ -161,6 +161,17 @@ export interface AgentOptions {
      * Cursor tool result callback for exec tool responses.
      */
     cursorOnToolResult?: CursorToolResultHandler;
+    /** Current working directory used by local tool execution. */
+    cwd?: string;
+    /**
+     * Resolver for the live working directory, re-read on every turn. When set, it
+     * overrides the static {@link cwd} at config-build time so a session move
+     * (`/move`, which updates the host's cwd without reconstructing the Agent) is
+     * reflected in provider options — e.g. GitLab Duo Agent namespace/project
+     * discovery keys off this cwd's git remote. Falls back to `cwd` when it returns
+     * `undefined`.
+     */
+    cwdResolver?: () => string | undefined;
     /**
      * Called after a tool call has been validated and is about to execute.
      * See {@link AgentLoopConfig.beforeToolCall} for full semantics.

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ export * from "./agent-loop";
 export * from "./append-only-context";
 export * from "./compaction";
 export * from "./proxy";
+export * from "./replay-policy";
 export * from "./run-collector";
 export * from "./telemetry";
 export * from "./thinking";

package/dist/types/replay-policy.d.ts

@@ -0,0 +1,5 @@
+import type { AssistantMessage, Message } from "@oh-my-pi/pi-ai";
+/** Detects API-level provider refusals that are terminal errors, not dialogue to replay. */
+export declare function isProviderRefusalMessage(message: AssistantMessage): boolean;
+/** Removes API-level provider refusals from live provider replay while preserving other messages. */
+export declare function filterProviderReplayMessages(messages: readonly Message[]): Message[];

package/dist/types/types.d.ts

@@ -284,6 +284,16 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * serving path while leaving the OpenAI/Anthropic tier untouched).
      */
     getServiceTier?: (model: Model) => ServiceTier | undefined;
+    /**
+     * Per-call working-directory resolver, read once per LLM call. When set, its
+     * return value overrides the static {@link SimpleStreamOptions.cwd} for the
+     * request (falling back to that static `cwd` when it returns `undefined`).
+     * Lets the host reflect a session move (`/move`, which updates the working
+     * directory without reconstructing the loop config) into provider options —
+     * e.g. GitLab Duo Agent namespace/project discovery keys off this cwd's git
+     * remote, so a stale value would strand discovery on the original repo.
+     */
+    getCwd?: () => string | undefined;
     /**
      * Called after a tool call has been validated and is about to execute.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "16.1.23",
+	"version": "16.2.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -35,12 +35,12 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "16.1.23",
-		"@oh-my-pi/pi-catalog": "16.1.23",
-		"@oh-my-pi/pi-natives": "16.1.23",
-		"@oh-my-pi/pi-utils": "16.1.23",
-		"@oh-my-pi/pi-wire": "16.1.23",
-		"@oh-my-pi/snapcompact": "16.1.23",
+		"@oh-my-pi/pi-ai": "16.2.0",
+		"@oh-my-pi/pi-catalog": "16.2.0",
+		"@oh-my-pi/pi-natives": "16.2.0",
+		"@oh-my-pi/pi-utils": "16.2.0",
+		"@oh-my-pi/pi-wire": "16.2.0",
+		"@oh-my-pi/snapcompact": "16.2.0",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -1225,6 +1225,9 @@ async function streamAssistantResponse(
 	const effectiveToolChoice = ownedDialect ? undefined : (hostToolChoice ?? forcedToolChoice ?? config.toolChoice);
 	const effectiveReasoning = dynamicReasoning ?? config.reasoning;
 	const effectiveDisableReasoning = dynamicDisableReasoning ?? config.disableReasoning;
+	// `getCwd` is read once per LLM call so a mid-run session move (`/move`) reaches
+	// workspace-scoped provider discovery; falls back to the static `cwd` when unset.
+	const effectiveCwd = config.getCwd?.() ?? config.cwd;
 
 	const chatStepNumber = stepCounter.count;
 	stepCounter.count += 1;
@@ -1276,6 +1279,7 @@ async function streamAssistantResponse(
 				disableReasoning: effectiveDisableReasoning,
 				temperature: effectiveTemperature,
 				serviceTier: effectiveServiceTier,
+				cwd: effectiveCwd,
 				signal: finalRequestSignal,
 				onResponse: captureOnResponse,
 			});

package/src/agent.ts

@@ -36,6 +36,7 @@ import {
 	resolveOwnedDialectFromEnv,
 } from "./agent-loop";
 import type { AppendOnlyContextManager } from "./append-only-context";
+import { isProviderRefusalMessage } from "./replay-policy";
 import type {
 	AgentContext,
 	AgentEvent,
@@ -54,10 +55,13 @@ import { isSoftToolRequirement } from "./types";
 import { EventLoopKeepalive } from "./utils/yield";
 
 /**
- * Default convertToLlm: Keep only LLM-compatible messages, convert attachments.
+ * Default convertToLlm: Keep only LLM-compatible replay messages.
  */
 function defaultConvertToLlm(messages: AgentMessage[]): Message[] {
-	return messages.filter((m): m is Message => m.role === "user" || m.role === "assistant" || m.role === "toolResult");
+	return messages.filter((m): m is Message => {
+		if (m.role === "assistant") return !isProviderRefusalMessage(m);
+		return m.role === "user" || m.role === "toolResult";
+	});
 }
 
 const ANTHROPIC_OUTPUT_BLOCKED_PREFIX = "Output blocked by conten";
@@ -269,6 +273,17 @@ export interface AgentOptions {
 	 */
 	cursorOnToolResult?: CursorToolResultHandler;
 
+	/** Current working directory used by local tool execution. */
+	cwd?: string;
+	/**
+	 * Resolver for the live working directory, re-read on every turn. When set, it
+	 * overrides the static {@link cwd} at config-build time so a session move
+	 * (`/move`, which updates the host's cwd without reconstructing the Agent) is
+	 * reflected in provider options — e.g. GitLab Duo Agent namespace/project
+	 * discovery keys off this cwd's git remote. Falls back to `cwd` when it returns
+	 * `undefined`.
+	 */
+	cwdResolver?: () => string | undefined;
 	/**
 	 * Called after a tool call has been validated and is about to execute.
 	 * See {@link AgentLoopConfig.beforeToolCall} for full semantics.
@@ -355,6 +370,9 @@ export class Agent {
 	#getToolContext?: (toolCall?: ToolCallContext) => AgentToolContext | undefined;
 	#cursorExecHandlers?: CursorExecHandlers;
 	#cursorOnToolResult?: CursorToolResultHandler;
+	#cwd?: string;
+	#cwdResolver?: () => string | undefined;
+
 	#runningPrompt?: Promise<void>;
 	#resolveRunningPrompt?: () => void;
 	#kimiApiFormat?: "openai" | "anthropic";
@@ -430,6 +448,8 @@ export class Agent {
 		this.#getToolContext = opts.getToolContext;
 		this.#cursorExecHandlers = opts.cursorExecHandlers;
 		this.#cursorOnToolResult = opts.cursorOnToolResult;
+		this.#cwd = opts.cwd;
+		this.#cwdResolver = opts.cwdResolver;
 		this.#kimiApiFormat = opts.kimiApiFormat;
 		this.#preferWebsockets = opts.preferWebsockets;
 		this.#transformToolCallArguments = opts.transformToolCallArguments;
@@ -1134,6 +1154,8 @@ export class Agent {
 			},
 			cursorExecHandlers: this.#cursorExecHandlers,
 			cursorOnToolResult,
+			cwd: this.#cwd,
+			getCwd: this.#cwdResolver,
 			transformToolCallArguments: this.#transformToolCallArguments,
 			intentTracing: this.#intentTracing,
 			pruneToolDescriptions: this.#pruneToolDescriptions,

package/src/compaction/messages.ts

@@ -1,5 +1,4 @@
 import type {
-	AssistantMessage,
 	ImageContent,
 	Message,
 	MessageAttribution,
@@ -214,7 +213,7 @@ export function convertMessageToLlm(message: AgentMessage): Message | undefined
 		case "developer":
 			return { ...message, attribution: message.attribution ?? "agent" };
 		case "assistant":
-			return message as AssistantMessage;
+			return message;
 		case "toolResult":
 			return {
 				...message,

package/src/compaction/openai.ts

@@ -13,9 +13,9 @@
  */
 
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/errors";
-import { parseTextSignature } from "@oh-my-pi/pi-ai/providers/openai-shared";
+import { parseAzureDeploymentNameMap, parseTextSignature } from "@oh-my-pi/pi-ai/providers/openai-shared";
 import { transformMessages } from "@oh-my-pi/pi-ai/providers/transform-messages";
-import type { AssistantMessage, FetchImpl, Message, Model } from "@oh-my-pi/pi-ai/types";
+import type { Api, AssistantMessage, FetchImpl, Message, Model } from "@oh-my-pi/pi-ai/types";
 import {
 	getOpenAIResponsesHistoryItems,
 	getOpenAIResponsesHistoryPayload,
@@ -27,7 +27,7 @@ import {
 	OPENAI_HEADER_VALUES,
 	OPENAI_HEADERS,
 } from "@oh-my-pi/pi-catalog/wire/codex";
-import { logger } from "@oh-my-pi/pi-utils";
+import { $env, logger } from "@oh-my-pi/pi-utils";
 
 // ============================================================================
 // Public types
@@ -45,6 +45,8 @@ export const OPENAI_REMOTE_COMPACTION_PRESERVE_KEY = "openaiRemoteCompaction";
  */
 export const REMOTE_COMPACTION_TIMEOUT_MS = 180_000;
 
+const DEFAULT_AZURE_API_VERSION = "v1";
+
 /** Race the caller's signal against the request timeout; `timeoutMs <= 0` disables the watchdog. */
 function withRequestTimeout(signal: AbortSignal | undefined, timeoutMs: number): AbortSignal | undefined {
 	if (timeoutMs <= 0) return signal;
@@ -86,12 +88,25 @@ export interface RemoteCompactionResponse {
 // OpenAI provider gating + endpoint resolution
 // ============================================================================
 
+function isOpenAiRemoteCompactionApi(api: Api | undefined): boolean {
+	return api === "openai-responses" || api === "azure-openai-responses" || api === "openai-codex-responses";
+}
+
 export function shouldUseOpenAiRemoteCompaction(model: Model): boolean {
-	return model.provider === "openai" || model.provider === "openai-codex";
+	if (model.remoteCompaction?.enabled === false) return false;
+	if (model.provider === "openai" || model.provider === "openai-codex") return true;
+	if (model.remoteCompaction?.enabled !== true) return false;
+	return isOpenAiRemoteCompactionApi(model.remoteCompaction.api ?? model.api);
 }
 
 function resolveOpenAiCompactEndpoint(model: Model): string {
-	if (model.provider === "openai-codex") {
+	const configuredEndpoint = model.remoteCompaction?.endpoint;
+	const compactionApi = model.remoteCompaction?.api ?? model.api;
+	if (compactionApi === "azure-openai-responses") {
+		return resolveAzureOpenAiCompactEndpoint(model, configuredEndpoint);
+	}
+	if (configuredEndpoint && configuredEndpoint.length > 0) return configuredEndpoint;
+	if (model.provider === "openai-codex" || compactionApi === "openai-codex-responses") {
 		return resolveOpenAiCodexCompactEndpoint(model.baseUrl);
 	}
 
@@ -102,6 +117,41 @@ function resolveOpenAiCompactEndpoint(model: Model): string {
 	return `${normalizedBase}/v1/responses/compact`;
 }
 
+function resolveAzureOpenAiCompactEndpoint(model: Model, configuredEndpoint: string | undefined): string {
+	const endpoint =
+		configuredEndpoint && configuredEndpoint.length > 0
+			? configuredEndpoint
+			: `${resolveAzureOpenAiBaseUrl(model)}/responses/compact`;
+	return appendAzureApiVersion(endpoint);
+}
+
+function resolveAzureOpenAiBaseUrl(model: Model): string {
+	const baseUrl = $env.AZURE_OPENAI_BASE_URL?.trim() || undefined;
+	const resourceName = $env.AZURE_OPENAI_RESOURCE_NAME;
+	const resolvedBaseUrl =
+		baseUrl ?? (resourceName ? `https://${resourceName}.openai.azure.com/openai/v1` : undefined) ?? model.baseUrl;
+	if (!resolvedBaseUrl) {
+		throw new Error(
+			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or configure model.baseUrl.",
+		);
+	}
+	return resolvedBaseUrl.replace(/\/+$/, "");
+}
+
+function appendAzureApiVersion(endpoint: string): string {
+	if (/[?&]api-version=/.test(endpoint)) return endpoint;
+	const separator = endpoint.includes("?") ? "&" : "?";
+	return `${endpoint}${separator}api-version=${encodeURIComponent($env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION)}`;
+}
+
+function resolveOpenAiCompactModel(model: Model): string {
+	const requestModel = model.remoteCompaction?.model ?? model.requestModelId ?? model.id;
+	const compactionApi = model.remoteCompaction?.api ?? model.api;
+	if (compactionApi !== "azure-openai-responses") return requestModel;
+	const mappedDeployment = parseAzureDeploymentNameMap($env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(requestModel);
+	return mappedDeployment ?? requestModel;
+}
+
 function resolveOpenAiCodexCompactEndpoint(baseUrl: string | undefined): string {
 	const rawBase = baseUrl && baseUrl.length > 0 ? baseUrl : CODEX_BASE_URL;
 	const normalizedBase = rawBase.endsWith("/") ? rawBase.slice(0, -1) : rawBase;
@@ -444,7 +494,6 @@ export function buildOpenAiNativeHistory(
 // ============================================================================
 // Endpoint requests
 // ============================================================================
-
 export async function requestOpenAiRemoteCompaction(
 	model: Model,
 	apiKey: string,
@@ -454,16 +503,24 @@ export async function requestOpenAiRemoteCompaction(
 	opts?: { fetch?: FetchImpl; timeoutMs?: number },
 ): Promise<OpenAiRemoteCompactionResponse> {
 	const endpoint = resolveOpenAiCompactEndpoint(model);
+	const requestModel = resolveOpenAiCompactModel(model);
 	const request: OpenAiRemoteCompactionRequest = {
-		model: model.id,
+		model: requestModel,
 		input: trimOpenAiCompactInput(compactInput, model.contextWindow ?? Number.POSITIVE_INFINITY, instructions),
 		instructions,
 	};
-	const headers: Record<string, string> = {
-		"content-type": "application/json",
-		Authorization: `Bearer ${apiKey}`,
-		...(model.headers ?? {}),
-	};
+	const isAzureOpenAiResponses = (model.remoteCompaction?.api ?? model.api) === "azure-openai-responses";
+	const headers: Record<string, string> = isAzureOpenAiResponses
+		? {
+				"content-type": "application/json",
+				"api-key": apiKey,
+				...(model.headers ?? {}),
+			}
+		: {
+				"content-type": "application/json",
+				Authorization: `Bearer ${apiKey}`,
+				...(model.headers ?? {}),
+			};
 
 	// Codex endpoints require additional auth headers
 	if (model.provider === "openai-codex") {

package/src/index.ts

@@ -8,6 +8,8 @@ export * from "./append-only-context";
 export * from "./compaction";
 // Proxy utilities
 export * from "./proxy";
+// Replay policy
+export * from "./replay-policy";
 // Run-level telemetry collector + aggregators
 export * from "./run-collector";
 // Telemetry

package/src/proxy.ts

@@ -13,9 +13,8 @@ import {
 	type StopReason,
 	type ToolCall,
 } from "@oh-my-pi/pi-ai";
-import { parseStreamingJson } from "@oh-my-pi/pi-ai/utils/json-parse";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { readSseJson } from "@oh-my-pi/pi-utils";
+import { parseStreamingJson, readSseJson } from "@oh-my-pi/pi-utils";
 
 // Event stream adapter for proxy SSE events
 export class ProxyMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
@@ -157,11 +156,12 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 			}
 
 			let sawTerminalEvent = false;
+			const partialJsonByIndex = new Map<number, string>();
 			for await (const event of readSseJson<ProxyAssistantMessageEvent>(
 				response.body as ReadableStream<Uint8Array>,
 				options.signal,
 			)) {
-				const parsedEvent = processProxyEvent(model, event, partial);
+				const parsedEvent = processProxyEvent(model, event, partial, partialJsonByIndex);
 				if (parsedEvent) {
 					if (parsedEvent.type === "done" || parsedEvent.type === "error") {
 						sawTerminalEvent = true;
@@ -183,6 +183,7 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			const reason = options.signal?.aborted ? "aborted" : "error";
 			partial.stopReason = reason;
+			scrubPartialJson(partial);
 			partial.errorMessage = errorMessage;
 			stream.push({
 				type: "error",
@@ -200,13 +201,33 @@ export function streamProxy(model: Model, context: Context, options: ProxyStream
 	return stream;
 }
 
+/**
+ * Remove the `partialJson` streaming field from any tool-call content blocks
+ * that still carry it (e.g. when the stream ended without a `toolcall_end`).
+ */
+function scrubPartialJson(partial: AssistantMessage): void {
+	for (const block of partial.content) {
+		if (block?.type === "toolCall") {
+			delete (block as ToolCall & { partialJson?: string }).partialJson;
+		}
+	}
+}
+
 /**
  * Process a proxy event and update the partial message.
+ *
+ * Streaming `partialJson` for in-progress tool calls is accumulated in a
+ * side-channel map keyed by `contentIndex` and also written onto the content
+ * object (as a typed intersection field) so downstream renderers can read it
+ * during streaming. The field is deleted at `toolcall_end` and scrubbed from
+ * any remaining blocks at `done`/`error` to guarantee it never leaks into the
+ * final `AssistantMessage`.
  */
 function processProxyEvent(
 	model: Model,
 	proxyEvent: ProxyAssistantMessageEvent,
 	partial: AssistantMessage,
+	partialJsonByIndex: Map<number, string>,
 ): AssistantMessageEvent | undefined {
 	switch (proxyEvent.type) {
 		case "start":
@@ -295,14 +316,16 @@ function processProxyEvent(
 				name: proxyEvent.toolName,
 				arguments: {},
 				partialJson: "",
-			} satisfies ToolCall & { partialJson: string } as ToolCall;
+			} as ToolCall & { partialJson: string };
+			partialJsonByIndex.set(proxyEvent.contentIndex, "");
 			return { type: "toolcall_start", contentIndex: proxyEvent.contentIndex, partial };
-
 		case "toolcall_delta": {
 			const content = partial.content[proxyEvent.contentIndex];
 			if (content?.type === "toolCall") {
-				(content as any).partialJson += proxyEvent.delta;
-				content.arguments = parseStreamingJson((content as any).partialJson) || {};
+				const acc = (partialJsonByIndex.get(proxyEvent.contentIndex) ?? "") + proxyEvent.delta;
+				partialJsonByIndex.set(proxyEvent.contentIndex, acc);
+				content.arguments = parseStreamingJson(acc) || {};
+				(content as ToolCall & { partialJson: string }).partialJson = acc;
 				partial.content[proxyEvent.contentIndex] = { ...content }; // Trigger reactivity
 				return {
 					type: "toolcall_delta",
@@ -317,7 +340,8 @@ function processProxyEvent(
 		case "toolcall_end": {
 			const content = partial.content[proxyEvent.contentIndex];
 			if (content?.type === "toolCall") {
-				delete (content as any).partialJson;
+				partialJsonByIndex.delete(proxyEvent.contentIndex);
+				delete (content as ToolCall & { partialJson?: string }).partialJson;
 				return {
 					type: "toolcall_end",
 					contentIndex: proxyEvent.contentIndex,
@@ -332,6 +356,7 @@ function processProxyEvent(
 			partial.stopReason = proxyEvent.reason;
 			partial.usage = proxyEvent.usage;
 			calculateCost(model, partial.usage);
+			scrubPartialJson(partial);
 			return { type: "done", reason: proxyEvent.reason, message: partial };
 
 		case "error":
@@ -339,6 +364,7 @@ function processProxyEvent(
 			partial.errorMessage = proxyEvent.errorMessage;
 			partial.usage = proxyEvent.usage;
 			calculateCost(model, partial.usage);
+			scrubPartialJson(partial);
 			return { type: "error", reason: proxyEvent.reason, error: partial };
 	}
 }

package/src/replay-policy.ts

@@ -0,0 +1,13 @@
+import type { AssistantMessage, Message } from "@oh-my-pi/pi-ai";
+
+/** Detects API-level provider refusals that are terminal errors, not dialogue to replay. */
+export function isProviderRefusalMessage(message: AssistantMessage): boolean {
+	if (message.stopReason !== "error") return false;
+	const stopType = message.stopDetails?.type;
+	return stopType === "refusal" || stopType === "sensitive";
+}
+
+/** Removes API-level provider refusals from live provider replay while preserving other messages. */
+export function filterProviderReplayMessages(messages: readonly Message[]): Message[] {
+	return messages.filter(message => message.role !== "assistant" || !isProviderRefusalMessage(message));
+}

package/src/types.ts

@@ -336,6 +336,17 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	 */
 	getServiceTier?: (model: Model) => ServiceTier | undefined;
 
+	/**
+	 * Per-call working-directory resolver, read once per LLM call. When set, its
+	 * return value overrides the static {@link SimpleStreamOptions.cwd} for the
+	 * request (falling back to that static `cwd` when it returns `undefined`).
+	 * Lets the host reflect a session move (`/move`, which updates the working
+	 * directory without reconstructing the loop config) into provider options —
+	 * e.g. GitLab Duo Agent namespace/project discovery keys off this cwd's git
+	 * remote, so a stale value would strand discovery on the original repo.
+	 */
+	getCwd?: () => string | undefined;
+
 	/**
 	 * Called after a tool call has been validated and is about to execute.
 	 *