pi-openai-toolkit 0.14.5 → 0.14.7

package/src/responses-headers.ts

@@ -1,11 +1,55 @@
 import type { ProviderHeaders } from "@earendil-works/pi-ai";
 import { mergeProviderHeaders } from "./provider-headers";
 
+export const CODEX_AFFINITY_SCOPE = "codex-session-v1" as const;
+export const CODEX_GATEWAY_ORIGINATOR = "codex_cli_rs" as const;
+
+/** Headers permitted from Pi/provider configuration onto the gateway hop. */
+export const CODEX_GATEWAY_FORWARD_HEADERS = [
+	"accept",
+	"content-type",
+	"session-id",
+	"thread-id",
+	"x-parent-session-id",
+	"x-codex-parent-thread-id",
+	"x-client-request-id",
+	"x-codex-model",
+	"x-codex-affinity-scope",
+	"x-codex-window-id",
+	"x-codex-turn-metadata",
+	"x-codex-beta-features",
+	"x-openai-encrypted-tool-arguments",
+	"x-openai-tool-output-truncation-policy",
+	"x-openai-internal-codex-responses-lite",
+	"version",
+	"originator",
+	"user-agent",
+] as const;
+
+const CODEX_GATEWAY_FORWARD_HEADER_SET = new Set<string>(CODEX_GATEWAY_FORWARD_HEADERS);
+
+export function filterCodexGatewayHeaders(headers: ProviderHeaders | undefined): Record<string, string> {
+	const result: Record<string, string> = {};
+	for (const [name, value] of Object.entries(headers ?? {})) {
+		if (typeof value !== "string" || !CODEX_GATEWAY_FORWARD_HEADER_SET.has(name.toLowerCase())) continue;
+		result[name] = value;
+	}
+	return result;
+}
+
+export type CodexAffinity = {
+	/** Bare model id used by the gateway route selector, never provider/model. */
+	model: string;
+	scope: typeof CODEX_AFFINITY_SCOPE;
+};
+
 export type ResponsesHeaderRuntime = {
 	api: string;
 	apiKey: string;
 	headers?: ProviderHeaders;
 	sessionId?: string;
+	/** Opt-in gateway Codex routing metadata for synthetic requests. */
+	codexAffinity?: CodexAffinity;
 	currentModel: {
 		headers?: ProviderHeaders;
 	};
@@ -39,6 +83,12 @@ function buildCodexUserAgent(): string {
 	return `pi (${platform}; ${arch})`;
 }
 
+export function buildCodexCliUserAgent(version: string): string {
+	const platform = typeof process !== "undefined" ? process.platform : "browser";
+	const arch = typeof process !== "undefined" ? process.arch : "unknown";
+	return `codex_cli_rs/${version} (${platform}; ${arch})`;
+}
+
 /**
  * The Codex backend version-gates model availability on the `version` header
  * (the pinned @openai/codex client version). `gpt-6-astra` requires >= 0.153.0;
@@ -68,8 +118,9 @@ export function buildResponsesRequestHeaders(
 	runtime: ResponsesHeaderRuntime,
 	options: ResponsesHeaderOptions,
 ): Headers {
+	const mergedHeaders = mergeProviderHeaders(runtime.currentModel.headers, runtime.headers);
 	const headers = new Headers(
-		mergeProviderHeaders(runtime.currentModel.headers, runtime.headers),
+		runtime.codexAffinity ? filterCodexGatewayHeaders(mergedHeaders) : mergedHeaders,
 	);
 	headers.set("accept", options.accept);
 	headers.set("content-type", options.contentType ?? "application/json");
@@ -77,19 +128,33 @@ export function buildResponsesRequestHeaders(
 		headers.set("authorization", `Bearer ${runtime.apiKey}`);
 	}
 
-	if (runtime.api === "openai-codex-responses") {
-		const accountId = extractCodexAccountId(runtime.apiKey);
-		if (accountId) headers.set("chatgpt-account-id", accountId);
-		headers.set("originator", "pi");
-		headers.set("user-agent", buildCodexUserAgent());
-		headers.set("openai-beta", "responses=experimental");
+	const isNativeCodex = runtime.api === "openai-codex-responses";
+	const gatewayAffinity = runtime.codexAffinity;
+	if (isNativeCodex || gatewayAffinity) {
+		if (gatewayAffinity) {
+			// A gateway request must use the configured data-plane key, never an
+			// inherited OAuth/account header from the model registry.
+			headers.set("authorization", `Bearer ${runtime.apiKey}`);
+			headers.delete("chatgpt-account-id");
+			headers.delete("cookie");
+			headers.delete("x-api-key");
+			headers.set("originator", CODEX_GATEWAY_ORIGINATOR);
+			headers.set("user-agent", buildCodexCliUserAgent(CODEX_CLIENT_VERSION));
+			headers.set("x-codex-affinity-scope", gatewayAffinity.scope);
+			headers.set("x-codex-model", gatewayAffinity.model);
+		} else {
+			const accountId = extractCodexAccountId(runtime.apiKey);
+			if (accountId) headers.set("chatgpt-account-id", accountId);
+			headers.set("originator", "pi");
+			headers.set("user-agent", buildCodexUserAgent());
+			headers.set("openai-beta", "responses=experimental");
+		}
 		// Codex backend gating: a request without a new-enough `version` never
 		// reaches model SKUs that arrived behind the gate (gpt-6-astra).
 		headers.set("version", CODEX_CLIENT_VERSION);
-		// Prompt-cache affinity rides on the conversation identity: the backend
-		// keeps a conversation's cache prefix on the node that wrote it, so our
-		// synthetic compaction requests must present the same id the live
-		// transcript requests used, or every compact pays a full cache miss.
+		// Prompt-cache/session affinity rides on the conversation identity. The
+		// gateway path also uses the bare model hint above so NEWapi can route
+		// context/compact requests without inspecting their body.
 		const sessionId = clampCodexSessionId(options.sessionId ?? runtime.sessionId);
 		if (sessionId) {
 			// Header names match the installed host's live-request builder

package/src/runtime.ts

@@ -1,5 +1,10 @@
 import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isExactModelAllowed } from "./model-scope";
+import {
+	CODEX_AFFINITY_SCOPE,
+	type CodexAffinity,
+} from "./responses-headers";
 import { RESPONSES_COMPACT_CAPABLE_APIS } from "./types";
 
 const OPENAI_RESPONSES_PATH = "responses";
@@ -24,6 +29,7 @@ export type NativeCompactionFailureReason =
 	| "model-not-found"
 	| "unsupported-api"
 	| "missing-base-url"
+	| "missing-session-id"
 	| "missing-api-key"
 	| "auth-resolution-failed"
 	| "unsupported-payload"
@@ -34,6 +40,8 @@ export type NativeCompactionSupportOptions = {
 	enabled?: boolean;
 	/** Which Responses APIs should use the compact endpoint; defaults to all capable APIs. */
 	responsesApis?: readonly string[];
+	/** Exact provider/model keys whose Responses traffic carries gateway Codex affinity metadata. */
+	codexGatewayModels?: readonly string[];
 };
 
 export type ResponsesSupportOptions = NativeCompactionSupportOptions;
@@ -60,6 +68,8 @@ export type ResponsesRuntime = {
 	 * requests used or the backend treats them as a new conversation.
 	 */
 	sessionId?: string;
+	/** Opt-in gateway Codex routing metadata for synthetic Responses/compact requests. */
+	codexAffinity?: CodexAffinity;
 	currentModel: RuntimeModel;
 };
 
@@ -130,6 +140,19 @@ function normalizeConfiguredApis(values: readonly string[] | undefined): Set<str
 	return new Set(values.map((value) => value.trim()).filter((value) => value.length > 0));
 }
 
+function resolveCodexGatewayAffinity(
+	model: RuntimeModel,
+	gatewayModels: readonly string[] | undefined,
+): CodexAffinity | undefined {
+	if (model.api !== "openai-responses" || !isExactModelAllowed(model, gatewayModels ?? [])) {
+		return undefined;
+	}
+	return {
+		model: model.id,
+		scope: CODEX_AFFINITY_SCOPE,
+	};
+}
+
 /** Parse "provider/model-id" (model ids may themselves contain slashes). */
 export function parseModelSpec(spec: string): ParsedModelSpec | undefined {
 	const trimmed = spec.trim();
@@ -329,6 +352,17 @@ async function resolveNativeCompactionEnvironmentForModel(
 		};
 	}
 
+	const codexAffinity = resolveCodexGatewayAffinity(currentModel, options.codexGatewayModels);
+	const sessionId = resolveRuntimeSessionId(ctx);
+	if (codexAffinity && !sessionId) {
+		return {
+			ok: false,
+			reason: "missing-session-id",
+			...descriptor,
+			baseUrl,
+		};
+	}
+
 	if (!auth.apiKey) {
 		return {
 			ok: false,
@@ -351,7 +385,8 @@ async function resolveNativeCompactionEnvironmentForModel(
 			responsesUrl: buildResponsesUrl(baseUrl, descriptor.api),
 			compactPath: buildCompactPath(descriptor.api),
 			compactUrl: buildCompactUrl(baseUrl, descriptor.api),
-			sessionId: resolveRuntimeSessionId(ctx),
+			sessionId,
+			codexAffinity,
 			payload: requestPayload,
 			currentModel,
 		},
@@ -378,6 +413,7 @@ export async function resolveResponsesEnvironment(
 			responsesPath: runtime.responsesPath,
 			responsesUrl: runtime.responsesUrl,
 			sessionId: runtime.sessionId,
+			codexAffinity: runtime.codexAffinity,
 			currentModel: runtime.currentModel,
 		},
 	};

package/src/web-search/extension.ts

@@ -1,80 +1,80 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadToolkitConfig } from "../config";
-import { transformWebSearchPayload } from "./payload";
-import { appendWebSearchPrompt } from "./prompt";
-import { isWebSearchEnabledForModel, type WebSearchModel } from "./types";
-
-function syncLocalWebSearchTool(
-	pi: ExtensionAPI,
-	model: WebSearchModel | undefined,
-	config: Parameters<typeof isWebSearchEnabledForModel>[1],
-	state: { wasActiveBeforeOwnership?: boolean; toolkitOwnsTool: boolean },
-): void {
-	const eligible = isWebSearchEnabledForModel(model, config);
-	const activeTools = pi.getActiveTools();
-
-	if (eligible) {
-		if (!state.toolkitOwnsTool) {
-			state.wasActiveBeforeOwnership = activeTools.includes("web_search");
-			state.toolkitOwnsTool = true;
-		}
-
-		if (activeTools.includes("web_search")) {
-			pi.setActiveTools(activeTools.filter((name) => name !== "web_search"));
-		}
-		return;
-	}
-
-	if (!state.toolkitOwnsTool) return;
-
-	if (state.wasActiveBeforeOwnership && !activeTools.includes("web_search")) {
-		pi.setActiveTools([...activeTools, "web_search"]);
-	}
-	state.wasActiveBeforeOwnership = undefined;
-	state.toolkitOwnsTool = false;
-}
-
-export function registerWebSearchExtension(
-	pi: ExtensionAPI,
-	loadConfig: typeof loadToolkitConfig = loadToolkitConfig,
-): void {
-	const toolState = { wasActiveBeforeOwnership: undefined as boolean | undefined, toolkitOwnsTool: false };
-
-	pi.on("session_start", (_event, ctx) => {
-		const { config } = loadConfig();
-		syncLocalWebSearchTool(pi, ctx.model, config.webSearch, toolState);
-	});
-
-	pi.on("model_select", (event) => {
-		const { config } = loadConfig();
-		syncLocalWebSearchTool(pi, event.model, config.webSearch, toolState);
-	});
-
-	pi.on("before_agent_start", (event, ctx) => {
-		const { config } = loadConfig();
-		syncLocalWebSearchTool(pi, ctx.model, config.webSearch, toolState);
-		const systemPrompt = appendWebSearchPrompt({
-			model: ctx.model,
-			config: config.webSearch,
-			systemPrompt: event.systemPrompt,
-		});
-
-		return systemPrompt === event.systemPrompt ? undefined : { systemPrompt };
-	});
-
-	pi.on("before_provider_request", (event, ctx) => {
-		const { config } = loadConfig();
-		syncLocalWebSearchTool(pi, ctx.model, config.webSearch, toolState);
-		const transformed = transformWebSearchPayload({
-			model: ctx.model,
-			config: config.webSearch,
-			payload: event.payload,
-		});
-
-		return transformed.changed ? transformed.payload : undefined;
-	});
-}
-
-export default function webSearchExtension(pi: ExtensionAPI): void {
-	registerWebSearchExtension(pi);
-}
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadToolkitConfig } from "../config";
+import { transformWebSearchPayload } from "./payload";
+import { appendWebSearchPrompt } from "./prompt";
+import { isWebSearchEnabledForModel, type WebSearchModel } from "./types";
+
+function syncLocalWebSearchTool(
+	pi: ExtensionAPI,
+	model: WebSearchModel | undefined,
+	config: Parameters<typeof isWebSearchEnabledForModel>[1],
+	state: { wasActiveBeforeOwnership?: boolean; toolkitOwnsTool: boolean },
+): void {
+	const eligible = isWebSearchEnabledForModel(model, config);
+	const activeTools = pi.getActiveTools();
+
+	if (eligible) {
+		if (!state.toolkitOwnsTool) {
+			state.wasActiveBeforeOwnership = activeTools.includes("web_search");
+			state.toolkitOwnsTool = true;
+		}
+
+		if (activeTools.includes("web_search")) {
+			pi.setActiveTools(activeTools.filter((name) => name !== "web_search"));
+		}
+		return;
+	}
+
+	if (!state.toolkitOwnsTool) return;
+
+	if (state.wasActiveBeforeOwnership && !activeTools.includes("web_search")) {
+		pi.setActiveTools([...activeTools, "web_search"]);
+	}
+	state.wasActiveBeforeOwnership = undefined;
+	state.toolkitOwnsTool = false;
+}
+
+export function registerWebSearchExtension(
+	pi: ExtensionAPI,
+	loadConfig: typeof loadToolkitConfig = loadToolkitConfig,
+): void {
+	const toolState = { wasActiveBeforeOwnership: undefined as boolean | undefined, toolkitOwnsTool: false };
+
+	pi.on("session_start", (_event, ctx) => {
+		const { config } = loadConfig();
+		syncLocalWebSearchTool(pi, ctx.model, config.webSearch, toolState);
+	});
+
+	pi.on("model_select", (event) => {
+		const { config } = loadConfig();
+		syncLocalWebSearchTool(pi, event.model, config.webSearch, toolState);
+	});
+
+	pi.on("before_agent_start", (event, ctx) => {
+		const { config } = loadConfig();
+		syncLocalWebSearchTool(pi, ctx.model, config.webSearch, toolState);
+		const systemPrompt = appendWebSearchPrompt({
+			model: ctx.model,
+			config: config.webSearch,
+			systemPrompt: event.systemPrompt,
+		});
+
+		return systemPrompt === event.systemPrompt ? undefined : { systemPrompt };
+	});
+
+	pi.on("before_provider_request", (event, ctx) => {
+		const { config } = loadConfig();
+		syncLocalWebSearchTool(pi, ctx.model, config.webSearch, toolState);
+		const transformed = transformWebSearchPayload({
+			model: ctx.model,
+			config: config.webSearch,
+			payload: event.payload,
+		});
+
+		return transformed.changed ? transformed.payload : undefined;
+	});
+}
+
+export default function webSearchExtension(pi: ExtensionAPI): void {
+	registerWebSearchExtension(pi);
+}

package/src/web-search/payload.ts

@@ -1,96 +1,96 @@
-import type { WebSearchConfig } from "../types";
-import {
-	WEB_SEARCH_SOURCE_INCLUDE,
-	isWebSearchEnabledForModel,
-	type WebSearchModel,
-	type WebSearchPayloadTransform,
-} from "./types";
-
-type JsonObject = Record<string, unknown>;
-
-function isRecord(value: unknown): value is JsonObject {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-function isLocalWebSearchFunction(tool: unknown): boolean {
-	return isRecord(tool) && tool.type === "function" && tool.name === "web_search";
-}
-
-function isNativeWebSearchTool(tool: unknown): boolean {
-	return isRecord(tool) && (tool.type === "web_search" || tool.type === "web_search_preview");
-}
-
-export function transformWebSearchPayload(args: {
-	model: WebSearchModel | undefined;
-	config: WebSearchConfig;
-	payload: unknown;
-}): WebSearchPayloadTransform {
-	const { model, config, payload } = args;
-	if (!config.enabled) {
-		return { payload, outcome: "disabled", changed: false };
-	}
-	if (!isWebSearchEnabledForModel(model, config)) {
-		return { payload, outcome: "unsupported-model", changed: false };
-	}
-	if (!isRecord(payload)) {
-		return { payload, outcome: "non-object-payload", changed: false };
-	}
-
-	const toolsValue = payload.tools;
-	if (toolsValue !== undefined && !Array.isArray(toolsValue)) {
-		return { payload, outcome: "invalid-tools", changed: false };
-	}
-	const tools = toolsValue ?? [];
-	const includeValue = payload.include;
-	if (includeValue !== undefined && !Array.isArray(includeValue)) {
-		return { payload, outcome: "invalid-include", changed: false };
-	}
-	const include = includeValue ?? [];
-	const normalizedTools: unknown[] = [];
-	let nativeToolCount = 0;
-	let localToolRemoved = false;
-	for (const tool of tools) {
-		if (isLocalWebSearchFunction(tool)) {
-			localToolRemoved = true;
-			continue;
-		}
-		if (isNativeWebSearchTool(tool)) {
-			nativeToolCount += 1;
-			if (nativeToolCount > 1) continue;
-		}
-		normalizedTools.push(tool);
-	}
-	const hasNativeTool = nativeToolCount > 0;
-	if (!hasNativeTool) {
-		normalizedTools.push({ type: "web_search" });
-	}
-
-	const normalizedInclude: unknown[] = [];
-	let sourceIncludeCount = 0;
-	for (const item of include) {
-		if (item === WEB_SEARCH_SOURCE_INCLUDE) {
-			sourceIncludeCount += 1;
-			if (sourceIncludeCount > 1) continue;
-		}
-		normalizedInclude.push(item);
-	}
-	if (sourceIncludeCount === 0) {
-		normalizedInclude.push(WEB_SEARCH_SOURCE_INCLUDE);
-	}
-
-	const toolsChanged = localToolRemoved || !hasNativeTool || nativeToolCount > 1;
-	const includeChanged = sourceIncludeCount !== 1;
-	if (!toolsChanged && !includeChanged) {
-		return { payload, outcome: "existing-native-tool", changed: false };
-	}
-
-	return {
-		payload: {
-			...payload,
-			...(toolsChanged ? { tools: normalizedTools } : {}),
-			...(includeChanged ? { include: normalizedInclude } : {}),
-		},
-		outcome: hasNativeTool ? "existing-native-tool" : "injected-native-tool",
-		changed: true,
-	};
-}
+import type { WebSearchConfig } from "../types";
+import {
+	WEB_SEARCH_SOURCE_INCLUDE,
+	isWebSearchEnabledForModel,
+	type WebSearchModel,
+	type WebSearchPayloadTransform,
+} from "./types";
+
+type JsonObject = Record<string, unknown>;
+
+function isRecord(value: unknown): value is JsonObject {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isLocalWebSearchFunction(tool: unknown): boolean {
+	return isRecord(tool) && tool.type === "function" && tool.name === "web_search";
+}
+
+function isNativeWebSearchTool(tool: unknown): boolean {
+	return isRecord(tool) && (tool.type === "web_search" || tool.type === "web_search_preview");
+}
+
+export function transformWebSearchPayload(args: {
+	model: WebSearchModel | undefined;
+	config: WebSearchConfig;
+	payload: unknown;
+}): WebSearchPayloadTransform {
+	const { model, config, payload } = args;
+	if (!config.enabled) {
+		return { payload, outcome: "disabled", changed: false };
+	}
+	if (!isWebSearchEnabledForModel(model, config)) {
+		return { payload, outcome: "unsupported-model", changed: false };
+	}
+	if (!isRecord(payload)) {
+		return { payload, outcome: "non-object-payload", changed: false };
+	}
+
+	const toolsValue = payload.tools;
+	if (toolsValue !== undefined && !Array.isArray(toolsValue)) {
+		return { payload, outcome: "invalid-tools", changed: false };
+	}
+	const tools = toolsValue ?? [];
+	const includeValue = payload.include;
+	if (includeValue !== undefined && !Array.isArray(includeValue)) {
+		return { payload, outcome: "invalid-include", changed: false };
+	}
+	const include = includeValue ?? [];
+	const normalizedTools: unknown[] = [];
+	let nativeToolCount = 0;
+	let localToolRemoved = false;
+	for (const tool of tools) {
+		if (isLocalWebSearchFunction(tool)) {
+			localToolRemoved = true;
+			continue;
+		}
+		if (isNativeWebSearchTool(tool)) {
+			nativeToolCount += 1;
+			if (nativeToolCount > 1) continue;
+		}
+		normalizedTools.push(tool);
+	}
+	const hasNativeTool = nativeToolCount > 0;
+	if (!hasNativeTool) {
+		normalizedTools.push({ type: "web_search" });
+	}
+
+	const normalizedInclude: unknown[] = [];
+	let sourceIncludeCount = 0;
+	for (const item of include) {
+		if (item === WEB_SEARCH_SOURCE_INCLUDE) {
+			sourceIncludeCount += 1;
+			if (sourceIncludeCount > 1) continue;
+		}
+		normalizedInclude.push(item);
+	}
+	if (sourceIncludeCount === 0) {
+		normalizedInclude.push(WEB_SEARCH_SOURCE_INCLUDE);
+	}
+
+	const toolsChanged = localToolRemoved || !hasNativeTool || nativeToolCount > 1;
+	const includeChanged = sourceIncludeCount !== 1;
+	if (!toolsChanged && !includeChanged) {
+		return { payload, outcome: "existing-native-tool", changed: false };
+	}
+
+	return {
+		payload: {
+			...payload,
+			...(toolsChanged ? { tools: normalizedTools } : {}),
+			...(includeChanged ? { include: normalizedInclude } : {}),
+		},
+		outcome: hasNativeTool ? "existing-native-tool" : "injected-native-tool",
+		changed: true,
+	};
+}

package/src/web-search/prompt.ts

@@ -1,20 +1,20 @@
-import type { WebSearchConfig } from "../types";
-import { isWebSearchEnabledForModel, WEB_SEARCH_PROMPT_MARKER, type WebSearchModel } from "./types";
-
-export const WEB_SEARCH_PROMPT_SECTION = `${WEB_SEARCH_PROMPT_MARKER}
-## Web Search
-
-The hosted \`web_search\` tool is part of your tool list for this model. The API executes it server-side: it is a real callable tool even though no client-side function schema or description accompanies it. Call it whenever current or online information matters instead of guessing, cite the returned sources in the answer, and never claim that web search or internet access is unavailable while this section is present.`;
-
-export function appendWebSearchPrompt(args: {
-	model: WebSearchModel | undefined;
-	config: WebSearchConfig;
-	systemPrompt: string;
-}): string {
-	const { model, config, systemPrompt } = args;
-	if (!isWebSearchEnabledForModel(model, config) || systemPrompt.includes(WEB_SEARCH_PROMPT_MARKER)) {
-		return systemPrompt;
-	}
-
-	return `${systemPrompt.trimEnd()}\n\n${WEB_SEARCH_PROMPT_SECTION}`;
-}
+import type { WebSearchConfig } from "../types";
+import { isWebSearchEnabledForModel, WEB_SEARCH_PROMPT_MARKER, type WebSearchModel } from "./types";
+
+export const WEB_SEARCH_PROMPT_SECTION = `${WEB_SEARCH_PROMPT_MARKER}
+## Web Search
+
+The hosted \`web_search\` tool is part of your tool list for this model. The API executes it server-side: it is a real callable tool even though no client-side function schema or description accompanies it. Call it whenever current or online information matters instead of guessing, cite the returned sources in the answer, and never claim that web search or internet access is unavailable while this section is present.`;
+
+export function appendWebSearchPrompt(args: {
+	model: WebSearchModel | undefined;
+	config: WebSearchConfig;
+	systemPrompt: string;
+}): string {
+	const { model, config, systemPrompt } = args;
+	if (!isWebSearchEnabledForModel(model, config) || systemPrompt.includes(WEB_SEARCH_PROMPT_MARKER)) {
+		return systemPrompt;
+	}
+
+	return `${systemPrompt.trimEnd()}\n\n${WEB_SEARCH_PROMPT_SECTION}`;
+}