feat(provider): add GitLab Duo Agent provider (Agent Platform)

.gitignore

@@ -44,6 +44,7 @@ packages/ai/test/.temp-images/
 .pi_config/
 .opencode/
 .worktrees/
+.worktree/
 compaction-results/
 changes/
 __pycache__/

packages/agent/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Added
+
+- Added an optional `cwdResolver` to `Agent` (and a `getCwd` per-call resolver on `AgentLoopConfig`) that is read once per LLM call to resolve the working directory, overriding the static `cwd` (falling back to it when the resolver returns `undefined`). Lets a host reflect a session move into provider options without reconstructing the agent — workspace-scoped provider discovery (e.g. GitLab Duo Agent namespace/project) now follows the live directory instead of the directory captured at construction.
+
 ## [16.1.16] - 2026-06-23
 
 ### Added
@@ -13,6 +17,10 @@
 
 - Updated `buildSideRequestContext` to allow pinning custom system prompts
 
+### Fixed
+
+- Fixed `Agent` forwarding the working directory (`cwd`) into provider stream options so the GitLab Duo Agent provider can scope local tool execution to the workspace.
+
 ## [16.1.10] - 2026-06-21
 
 ### Fixed
@@ -131,7 +139,6 @@
 ### Fixed
 
 - Fixed `pruneToolOutputs` blanking tiny tool results during overflow pruning: results below `50` tokens (`MIN_PRUNE_TOKENS`) are no longer replaced with the `[Output truncated - N tokens]` placeholder, which cost more tokens than the result itself and churned the prompt cache for zero savings.
-
 ## [15.13.2] - 2026-06-15
 
 ### Breaking Changes

packages/agent/src/agent-loop.ts

@@ -1221,6 +1221,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;
@@ -1272,6 +1275,7 @@ async function streamAssistantResponse(
 				disableReasoning: effectiveDisableReasoning,
 				temperature: effectiveTemperature,
 				serviceTier: effectiveServiceTier,
+				cwd: effectiveCwd,
 				signal: finalRequestSignal,
 				onResponse: captureOnResponse,
 			});

packages/agent/src/agent.ts

@@ -268,6 +268,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.
@@ -354,6 +365,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";
@@ -429,6 +443,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;
@@ -1129,6 +1145,8 @@ export class Agent {
 			},
 			cursorExecHandlers: this.#cursorExecHandlers,
 			cursorOnToolResult,
+			cwd: this.#cwd,
+			getCwd: this.#cwdResolver,
 			transformToolCallArguments: this.#transformToolCallArguments,
 			intentTracing: this.#intentTracing,
 			pruneToolDescriptions: this.#pruneToolDescriptions,

packages/agent/src/types.ts

@@ -327,6 +327,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.
 	 *

packages/agent/test/agent.test.ts

@@ -496,6 +496,78 @@ describe("Agent", () => {
 		expect(mock.calls[0]?.options?.promptCacheKey).toBe("parent-cache");
 	});
 
+	it("forwards the live cwd from cwdResolver to the stream, overriding the static cwd", async () => {
+		const mock = createMockModel({ responses: [{ content: ["ok"] }] });
+		const agent = new Agent({
+			initialState: { model: mock.model, messages: [] },
+			streamFn: mock.stream,
+			cwd: "/static/repo-a",
+			cwdResolver: () => "/live/repo-b",
+		});
+
+		await agent.prompt("run");
+
+		// The resolver wins over the constructor-time `cwd`: provider workspace
+		// discovery (e.g. GitLab Duo namespace/project) must key off the live dir.
+		expect(mock.calls[0]?.options?.cwd).toBe("/live/repo-b");
+	});
+
+	it("falls back to the static cwd when cwdResolver returns undefined", async () => {
+		const mock = createMockModel({ responses: [{ content: ["ok"] }] });
+		const agent = new Agent({
+			initialState: { model: mock.model, messages: [] },
+			streamFn: mock.stream,
+			cwd: "/static/repo-a",
+			cwdResolver: () => undefined,
+		});
+
+		await agent.prompt("run");
+
+		expect(mock.calls[0]?.options?.cwd).toBe("/static/repo-a");
+	});
+
+	it("re-reads cwd from cwdResolver for each model call within a run (a /move mid-run is seen)", async () => {
+		const toolSchema = z.object({ value: z.string() });
+		type Details = { value: string };
+		const alphaTool: AgentTool<typeof toolSchema, Details> = {
+			name: "alpha",
+			label: "Alpha",
+			description: "Alpha tool",
+			parameters: toolSchema,
+			async execute(_toolCallId, params) {
+				return { content: [{ type: "text", text: `alpha:${params.value}` }], details: { value: params.value } };
+			},
+		};
+
+		const mock = createMockModel({
+			responses: [
+				{ content: [{ type: "toolCall", id: "tool-1", name: "alpha", arguments: { value: "hello" } }] },
+				{ content: ["done"] },
+			],
+		});
+
+		// The host owns the live cwd; `cwdResolver` reads it on every config build.
+		let liveCwd = "/live/repo-a";
+		const agent = new Agent({
+			initialState: { model: mock.model, tools: [alphaTool], messages: [] },
+			streamFn: mock.stream,
+			cwdResolver: () => liveCwd,
+		});
+
+		// Simulate `/move` between the tool-call turn and the continuation request.
+		const unsubscribe = agent.subscribe(event => {
+			if (event.type === "message_end" && event.message.role === "toolResult") {
+				liveCwd = "/live/repo-b";
+			}
+		});
+
+		await agent.prompt("run");
+		unsubscribe();
+
+		const cwdPerCall = mock.calls.map(call => call.options?.cwd);
+		expect(cwdPerCall).toEqual(["/live/repo-a", "/live/repo-b"]);
+	});
+
 	it("returns static metadata via the plain setter", () => {
 		const agent = new Agent();
 		expect(agent.metadata).toBeUndefined();