@pixelzx/genesis 2026.6.6-1 → 2026.6.7

package/dist/tools-invoke-http-DcRsw9EO.js

@@ -1,206 +0,0 @@
-import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
-import { a as logWarn } from "./logger-BbnBrdB_.js";
-import { n as defaultSlotIdForKey } from "./slots-BpEPHdhK.js";
-import { i as isTestDefaultMemorySlotDisabled } from "./config-state-B_obBded.js";
-import { u as normalizeMessageChannel } from "./message-channel-bhWoqTRw.js";
-import { i as resolveMainSessionKey } from "./main-session-C5R_Lg-0.js";
-import "./sessions-BaBnI48b.js";
-import { g as isKnownCoreToolId, n as applyOwnerOnlyToolPolicy } from "./tool-policy-C7XoKUjK.js";
-import { i as runBeforeToolCallHook } from "./pi-tools.before-tool-call-DgEuyrNS.js";
-import { r as ToolInputError } from "./common-BtK-bRqD.js";
-import { n as resolveToolLoopDetectionConfig } from "./pi-tools-DLzCdu_A.js";
-import { S as sendMethodNotAllowed, b as sendInvalidRequest, i as authorizeScopedGatewayHttpRequestOrReply, m as resolveOpenAiCompatibleHttpSenderIsOwner, p as resolveOpenAiCompatibleHttpOperatorScopes, s as getHeader, v as readJsonBodyOrError, x as sendJson } from "./http-utils-DFEeaWER.js";
-import { t as resolveGatewayScopedTools } from "./tool-resolution-CjbwGHcJ.js";
-//#region src/gateway/tools-invoke-http.ts
-const DEFAULT_BODY_BYTES = 2 * 1024 * 1024;
-const MEMORY_TOOL_NAMES = new Set(["memory_search", "memory_get"]);
-function resolveSessionKeyFromBody(body) {
-	if (typeof body.sessionKey === "string" && body.sessionKey.trim()) return body.sessionKey.trim();
-}
-function resolveMemoryToolDisableReasons(cfg) {
-	if (!process.env.VITEST) return [];
-	const reasons = [];
-	const plugins = cfg.plugins;
-	const slotRaw = plugins?.slots?.memory;
-	const slotDisabled = slotRaw === null || normalizeOptionalLowercaseString(slotRaw) === "none";
-	const pluginsDisabled = plugins?.enabled === false;
-	const defaultDisabled = isTestDefaultMemorySlotDisabled(cfg);
-	if (pluginsDisabled) reasons.push("plugins.enabled=false");
-	if (slotDisabled) reasons.push(slotRaw === null ? "plugins.slots.memory=null" : "plugins.slots.memory=\"none\"");
-	if (!pluginsDisabled && !slotDisabled && defaultDisabled) reasons.push("memory plugin disabled by test default");
-	return reasons;
-}
-function mergeActionIntoArgsIfSupported(params) {
-	const { toolSchema, action, args } = params;
-	if (!action) return args;
-	if (args.action !== void 0) return args;
-	const schemaObj = toolSchema;
-	if (!Boolean(schemaObj && typeof schemaObj === "object" && schemaObj.properties && "action" in schemaObj.properties)) return args;
-	return {
-		...args,
-		action
-	};
-}
-function getErrorMessage(err) {
-	if (err instanceof Error) return err.message || String(err);
-	if (typeof err === "string") return err;
-	return String(err);
-}
-function resolveToolInputErrorStatus(err) {
-	if (err instanceof ToolInputError) {
-		const status = err.status;
-		return typeof status === "number" ? status : 400;
-	}
-	if (typeof err !== "object" || err === null || !("name" in err)) return null;
-	const name = err.name;
-	if (name !== "ToolInputError" && name !== "ToolAuthorizationError") return null;
-	const status = err.status;
-	if (typeof status === "number") return status;
-	return name === "ToolAuthorizationError" ? 403 : 400;
-}
-async function handleToolsInvokeHttpRequest(req, res, opts) {
-	let url;
-	try {
-		url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-	} catch {
-		res.writeHead(400, { "Content-Type": "application/json" });
-		res.end(JSON.stringify({
-			error: "bad_request",
-			message: "Invalid request URL"
-		}));
-		return true;
-	}
-	if (url.pathname !== "/tools/invoke") return false;
-	if (req.method !== "POST") {
-		sendMethodNotAllowed(res, "POST");
-		return true;
-	}
-	const authResult = await authorizeScopedGatewayHttpRequestOrReply({
-		req,
-		res,
-		auth: opts.auth,
-		trustedProxies: opts.trustedProxies,
-		allowRealIpFallback: opts.allowRealIpFallback,
-		rateLimiter: opts.rateLimiter,
-		operatorMethod: "agent",
-		resolveOperatorScopes: resolveOpenAiCompatibleHttpOperatorScopes
-	});
-	if (!authResult) return true;
-	const { cfg, requestAuth } = authResult;
-	const bodyUnknown = await readJsonBodyOrError(req, res, opts.maxBodyBytes ?? DEFAULT_BODY_BYTES);
-	if (bodyUnknown === void 0) return true;
-	const body = bodyUnknown ?? {};
-	const toolName = normalizeOptionalString(body.tool) ?? "";
-	if (!toolName) {
-		sendInvalidRequest(res, "tools.invoke requires body.tool");
-		return true;
-	}
-	if (process.env.VITEST && MEMORY_TOOL_NAMES.has(toolName)) {
-		const reasons = resolveMemoryToolDisableReasons(cfg);
-		if (reasons.length > 0) {
-			sendJson(res, 400, {
-				ok: false,
-				error: {
-					type: "invalid_request",
-					message: `memory tools are disabled in tests${reasons.length > 0 ? ` (${reasons.join(", ")})` : ""}. Enable by setting plugins.slots.memory="${defaultSlotIdForKey("memory")}" (and ensure plugins.enabled is not false).`
-				}
-			});
-			return true;
-		}
-	}
-	const action = normalizeOptionalString(body.action);
-	const argsRaw = body.args;
-	const args = argsRaw && typeof argsRaw === "object" && !Array.isArray(argsRaw) ? argsRaw : {};
-	const rawSessionKey = resolveSessionKeyFromBody(body);
-	const sessionKey = !rawSessionKey || rawSessionKey === "main" ? resolveMainSessionKey(cfg) : rawSessionKey;
-	const messageChannel = normalizeMessageChannel(getHeader(req, "x-genesis-message-channel") ?? "");
-	const accountId = normalizeOptionalString(getHeader(req, "x-genesis-account-id"));
-	const agentTo = normalizeOptionalString(getHeader(req, "x-genesis-message-to"));
-	const agentThreadId = normalizeOptionalString(getHeader(req, "x-genesis-thread-id"));
-	const senderIsOwner = resolveOpenAiCompatibleHttpSenderIsOwner(req, requestAuth);
-	const resolveTools = (disablePluginTools) => resolveGatewayScopedTools({
-		cfg,
-		sessionKey,
-		messageProvider: messageChannel ?? void 0,
-		accountId,
-		agentTo,
-		agentThreadId,
-		allowGatewaySubagentBinding: true,
-		allowMediaInvokeCommands: true,
-		surface: "http",
-		disablePluginTools,
-		senderIsOwner
-	});
-	const knownCoreTool = isKnownCoreToolId(toolName);
-	let { agentId, tools } = resolveTools(knownCoreTool);
-	if (knownCoreTool && !tools.some((candidate) => candidate.name === toolName)) ({agentId, tools} = resolveTools(false));
-	const tool = applyOwnerOnlyToolPolicy(tools, senderIsOwner).find((t) => t.name === toolName);
-	if (!tool) {
-		sendJson(res, 404, {
-			ok: false,
-			error: {
-				type: "not_found",
-				message: `Tool not available: ${toolName}`
-			}
-		});
-		return true;
-	}
-	try {
-		const gatewayTool = tool;
-		const toolCallId = `http-${Date.now()}`;
-		const hookResult = await runBeforeToolCallHook({
-			toolName,
-			params: mergeActionIntoArgsIfSupported({
-				toolSchema: gatewayTool.parameters,
-				action,
-				args
-			}),
-			toolCallId,
-			ctx: {
-				agentId,
-				sessionKey,
-				loopDetection: resolveToolLoopDetectionConfig({
-					cfg,
-					agentId
-				})
-			}
-		});
-		if (hookResult.blocked) {
-			sendJson(res, 403, {
-				ok: false,
-				error: {
-					type: "tool_call_blocked",
-					message: hookResult.reason
-				}
-			});
-			return true;
-		}
-		sendJson(res, 200, {
-			ok: true,
-			result: await gatewayTool.execute?.(toolCallId, hookResult.params)
-		});
-	} catch (err) {
-		const inputStatus = resolveToolInputErrorStatus(err);
-		if (inputStatus !== null) {
-			sendJson(res, inputStatus, {
-				ok: false,
-				error: {
-					type: "tool_error",
-					message: getErrorMessage(err) || "invalid tool arguments"
-				}
-			});
-			return true;
-		}
-		logWarn(`tools-invoke: tool execution failed: ${String(err)}`);
-		sendJson(res, 500, {
-			ok: false,
-			error: {
-				type: "tool_error",
-				message: "tool execution failed"
-			}
-		});
-	}
-	return true;
-}
-//#endregion
-export { handleToolsInvokeHttpRequest };

package/dist/tools.runtime-B-fcXtvL.js

@@ -1,4 +0,0 @@
-import { n as readAgentMemoryFile, t as resolveMemoryBackendConfig } from "./backend-config-COiFxgN3.js";
-import "./memory-core-host-runtime-files-ALnEstzC.js";
-import { n as getMemorySearchManager } from "./memory-Cvmtd7SS.js";
-export { getMemorySearchManager, readAgentMemoryFile, resolveMemoryBackendConfig };

package/dist/transcript-CTF8zJ2t.js

@@ -1,312 +0,0 @@
-import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
-import { a as resolveSessionFilePathOptions, i as resolveSessionFilePath, o as resolveSessionTranscriptPath, r as resolveDefaultSessionStorePath } from "./paths-CV1IubzZ.js";
-import { t as loadSessionStore } from "./store-load-DaPvctit.js";
-import { c as normalizeStoreSessionKey, o as updateSessionStore } from "./store-DOwpgFxf.js";
-import { t as emitSessionTranscriptUpdate } from "./transcript-events-NZm-Lpzi.js";
-import { t as parseSessionThreadInfo } from "./thread-info-CgEQRcvu.js";
-import fs from "node:fs";
-import path from "node:path";
-import { CURRENT_SESSION_VERSION, SessionManager } from "@earendil-works/pi-coding-agent";
-//#region src/config/sessions/session-file.ts
-async function resolveAndPersistSessionFile(params) {
-	const { sessionId, sessionKey, sessionStore, storePath } = params;
-	const baseEntry = params.sessionEntry ?? sessionStore[sessionKey] ?? {
-		sessionId,
-		updatedAt: Date.now()
-	};
-	const shouldReusePersistedSessionFile = baseEntry.sessionId === sessionId;
-	const fallbackSessionFile = params.fallbackSessionFile?.trim();
-	const sessionFile = resolveSessionFilePath(sessionId, !shouldReusePersistedSessionFile ? fallbackSessionFile ? {
-		...baseEntry,
-		sessionFile: fallbackSessionFile
-	} : {
-		...baseEntry,
-		sessionFile: void 0
-	} : !baseEntry.sessionFile && fallbackSessionFile ? {
-		...baseEntry,
-		sessionFile: fallbackSessionFile
-	} : baseEntry, {
-		agentId: params.agentId,
-		sessionsDir: params.sessionsDir
-	});
-	const persistedEntry = {
-		...baseEntry,
-		sessionId,
-		updatedAt: Date.now(),
-		sessionFile
-	};
-	if (baseEntry.sessionId !== sessionId || baseEntry.sessionFile !== sessionFile) {
-		sessionStore[sessionKey] = persistedEntry;
-		await updateSessionStore(storePath, (store) => {
-			store[sessionKey] = {
-				...store[sessionKey],
-				...persistedEntry
-			};
-		}, params.activeSessionKey || params.maintenanceConfig ? {
-			...params.activeSessionKey ? { activeSessionKey: params.activeSessionKey } : {},
-			...params.maintenanceConfig ? { maintenanceConfig: params.maintenanceConfig } : {}
-		} : void 0);
-		return {
-			sessionFile,
-			sessionEntry: persistedEntry
-		};
-	}
-	sessionStore[sessionKey] = persistedEntry;
-	return {
-		sessionFile,
-		sessionEntry: persistedEntry
-	};
-}
-//#endregion
-//#region src/config/sessions/transcript-mirror.ts
-function stripQuery(value) {
-	const noHash = value.split("#")[0] ?? value;
-	return noHash.split("?")[0] ?? noHash;
-}
-function extractFileNameFromMediaUrl(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	const cleaned = stripQuery(trimmed);
-	try {
-		const parsed = new URL(cleaned);
-		const base = path.basename(parsed.pathname);
-		if (!base) return null;
-		try {
-			return decodeURIComponent(base);
-		} catch {
-			return base;
-		}
-	} catch {
-		const base = path.basename(cleaned);
-		if (!base || base === "/" || base === ".") return null;
-		return base;
-	}
-}
-function resolveMirroredTranscriptText(params) {
-	const mediaUrls = params.mediaUrls?.filter((url) => url && url.trim()) ?? [];
-	if (mediaUrls.length > 0) {
-		const names = mediaUrls.map((url) => extractFileNameFromMediaUrl(url)).filter((name) => Boolean(name && name.trim()));
-		if (names.length > 0) return names.join(", ");
-		return "media";
-	}
-	const trimmed = (params.text ?? "").trim();
-	return trimmed ? trimmed : null;
-}
-//#endregion
-//#region src/config/sessions/transcript.ts
-async function ensureSessionHeader(params) {
-	if (fs.existsSync(params.sessionFile)) return;
-	await fs.promises.mkdir(path.dirname(params.sessionFile), { recursive: true });
-	const header = {
-		type: "session",
-		version: CURRENT_SESSION_VERSION,
-		id: params.sessionId,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		cwd: process.cwd()
-	};
-	await fs.promises.writeFile(params.sessionFile, `${JSON.stringify(header)}\n`, {
-		encoding: "utf-8",
-		mode: 384
-	});
-}
-async function resolveSessionTranscriptFile(params) {
-	const sessionPathOpts = resolveSessionFilePathOptions({
-		agentId: params.agentId,
-		storePath: params.storePath
-	});
-	let sessionFile = resolveSessionFilePath(params.sessionId, params.sessionEntry, sessionPathOpts);
-	let sessionEntry = params.sessionEntry;
-	if (params.sessionStore && params.storePath) {
-		const threadIdFromSessionKey = parseSessionThreadInfo(params.sessionKey).threadId;
-		const fallbackSessionFile = !sessionEntry?.sessionFile ? resolveSessionTranscriptPath(params.sessionId, params.agentId, params.threadId ?? threadIdFromSessionKey) : void 0;
-		const resolvedSessionFile = await resolveAndPersistSessionFile({
-			sessionId: params.sessionId,
-			sessionKey: params.sessionKey,
-			sessionStore: params.sessionStore,
-			storePath: params.storePath,
-			sessionEntry,
-			agentId: sessionPathOpts?.agentId,
-			sessionsDir: sessionPathOpts?.sessionsDir,
-			fallbackSessionFile
-		});
-		sessionFile = resolvedSessionFile.sessionFile;
-		sessionEntry = resolvedSessionFile.sessionEntry;
-	}
-	return {
-		sessionFile,
-		sessionEntry
-	};
-}
-async function appendAssistantMessageToSessionTranscript(params) {
-	const sessionKey = params.sessionKey.trim();
-	if (!sessionKey) return {
-		ok: false,
-		reason: "missing sessionKey"
-	};
-	const mirrorText = resolveMirroredTranscriptText({
-		text: params.text,
-		mediaUrls: params.mediaUrls
-	});
-	if (!mirrorText) return {
-		ok: false,
-		reason: "empty text"
-	};
-	return appendExactAssistantMessageToSessionTranscript({
-		agentId: params.agentId,
-		sessionKey,
-		storePath: params.storePath,
-		idempotencyKey: params.idempotencyKey,
-		updateMode: params.updateMode,
-		message: {
-			role: "assistant",
-			content: [{
-				type: "text",
-				text: mirrorText
-			}],
-			api: "openai-responses",
-			provider: "genesis",
-			model: "delivery-mirror",
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: Date.now()
-		}
-	});
-}
-async function appendExactAssistantMessageToSessionTranscript(params) {
-	const sessionKey = params.sessionKey.trim();
-	if (!sessionKey) return {
-		ok: false,
-		reason: "missing sessionKey"
-	};
-	if (params.message.role !== "assistant") return {
-		ok: false,
-		reason: "message role must be assistant"
-	};
-	const storePath = params.storePath ?? resolveDefaultSessionStorePath(params.agentId);
-	const store = loadSessionStore(storePath, { skipCache: true });
-	const entry = store[normalizeStoreSessionKey(sessionKey)] ?? store[sessionKey];
-	if (!entry?.sessionId) return {
-		ok: false,
-		reason: `unknown sessionKey: ${sessionKey}`
-	};
-	let sessionFile;
-	try {
-		sessionFile = (await resolveAndPersistSessionFile({
-			sessionId: entry.sessionId,
-			sessionKey,
-			sessionStore: store,
-			storePath,
-			sessionEntry: entry,
-			agentId: params.agentId,
-			sessionsDir: path.dirname(storePath)
-		})).sessionFile;
-	} catch (err) {
-		return {
-			ok: false,
-			reason: formatErrorMessage(err)
-		};
-	}
-	await ensureSessionHeader({
-		sessionFile,
-		sessionId: entry.sessionId
-	});
-	const explicitIdempotencyKey = params.idempotencyKey ?? params.message.idempotencyKey;
-	const existingMessageId = explicitIdempotencyKey ? await transcriptHasIdempotencyKey(sessionFile, explicitIdempotencyKey) : void 0;
-	if (existingMessageId) return {
-		ok: true,
-		sessionFile,
-		messageId: existingMessageId
-	};
-	const latestEquivalentAssistantId = isRedundantDeliveryMirror(params.message) ? await findLatestEquivalentAssistantMessageId(sessionFile, params.message) : void 0;
-	if (latestEquivalentAssistantId) return {
-		ok: true,
-		sessionFile,
-		messageId: latestEquivalentAssistantId
-	};
-	const message = {
-		...params.message,
-		...explicitIdempotencyKey ? { idempotencyKey: explicitIdempotencyKey } : {}
-	};
-	const messageId = SessionManager.open(sessionFile).appendMessage(message);
-	switch (params.updateMode ?? "inline") {
-		case "inline":
-			emitSessionTranscriptUpdate({
-				sessionFile,
-				sessionKey,
-				message,
-				messageId
-			});
-			break;
-		case "file-only":
-			emitSessionTranscriptUpdate(sessionFile);
-			break;
-		case "none": break;
-	}
-	return {
-		ok: true,
-		sessionFile,
-		messageId
-	};
-}
-async function transcriptHasIdempotencyKey(transcriptPath, idempotencyKey) {
-	try {
-		const raw = await fs.promises.readFile(transcriptPath, "utf-8");
-		for (const line of raw.split(/\r?\n/)) {
-			if (!line.trim()) continue;
-			try {
-				const parsed = JSON.parse(line);
-				if (parsed.message?.idempotencyKey === idempotencyKey && typeof parsed.id === "string" && parsed.id) return parsed.id;
-			} catch {
-				continue;
-			}
-		}
-	} catch {
-		return;
-	}
-}
-function isRedundantDeliveryMirror(message) {
-	return message.provider === "genesis" && message.model === "delivery-mirror";
-}
-function extractAssistantMessageText(message) {
-	if (!Array.isArray(message.content)) return null;
-	const parts = message.content.filter((part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0).map((part) => part.text.trim());
-	return parts.length > 0 ? parts.join("\n").trim() : null;
-}
-async function findLatestEquivalentAssistantMessageId(transcriptPath, message) {
-	const expectedText = extractAssistantMessageText(message);
-	if (!expectedText) return;
-	try {
-		const lines = (await fs.promises.readFile(transcriptPath, "utf-8")).split(/\r?\n/);
-		for (let index = lines.length - 1; index >= 0; index -= 1) {
-			const line = lines[index];
-			if (!line.trim()) continue;
-			try {
-				const parsed = JSON.parse(line);
-				const candidate = parsed.message;
-				if (!candidate || candidate.role !== "assistant") continue;
-				if (extractAssistantMessageText(candidate) !== expectedText) return;
-				if (typeof parsed.id === "string" && parsed.id) return parsed.id;
-				return;
-			} catch {
-				continue;
-			}
-		}
-	} catch {
-		return;
-	}
-}
-//#endregion
-export { resolveAndPersistSessionFile as a, resolveMirroredTranscriptText as i, appendExactAssistantMessageToSessionTranscript as n, resolveSessionTranscriptFile as r, appendAssistantMessageToSessionTranscript as t };

package/dist/transcript-resolve.runtime-C41xgFnA.js

@@ -1,2 +0,0 @@
-import { r as resolveSessionTranscriptFile } from "./transcript-CTF8zJ2t.js";
-export { resolveSessionTranscriptFile };

package/dist/transcript.runtime-DNBFm0LS.js

@@ -1,2 +0,0 @@
-import { n as appendExactAssistantMessageToSessionTranscript, t as appendAssistantMessageToSessionTranscript } from "./transcript-CTF8zJ2t.js";
-export { appendAssistantMessageToSessionTranscript, appendExactAssistantMessageToSessionTranscript };

package/dist/transport-policy-Ivm5ArSd.js

@@ -1,75 +0,0 @@
-import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DPP_aYVc.js";
-import { r as normalizeProviderId } from "./provider-id--dmcBtHB.js";
-import "./provider-model-shared-dBY7nLZs.js";
-import "./text-runtime-BOpYwhuR.js";
-import { n as isOpenAICodexBaseUrl, t as isOpenAIApiBaseUrl } from "./base-url-h8Mhif7l.js";
-//#region extensions/openai/transport-policy.ts
-const DEFAULT_OPENAI_WS_DEGRADE_COOLDOWN_MS = 6e4;
-const AZURE_PROVIDER_IDS = new Set(["azure-openai", "azure-openai-responses"]);
-const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
-function isAzureOpenAIBaseUrl(baseUrl) {
-	const trimmed = baseUrl?.trim();
-	if (!trimmed) return false;
-	try {
-		return normalizeLowercaseStringOrEmpty(new URL(trimmed).hostname).endsWith(".openai.azure.com");
-	} catch {
-		return false;
-	}
-}
-function normalizeIdentityValue(value, maxLength = 160) {
-	const trimmed = value.trim().replace(/[\r\n]+/g, " ");
-	return trimmed.length > maxLength ? trimmed.slice(0, maxLength) : trimmed;
-}
-function usesKnownNativeOpenAIRoute(provider, baseUrl) {
-	const normalizedProvider = normalizeProviderId(provider);
-	if (!normalizedProvider) return false;
-	if (normalizedProvider === "openai") return !baseUrl || isOpenAIApiBaseUrl(baseUrl);
-	if (AZURE_PROVIDER_IDS.has(normalizedProvider)) return !baseUrl || isAzureOpenAIBaseUrl(baseUrl);
-	if (normalizedProvider === OPENAI_CODEX_PROVIDER_ID) return !baseUrl || isOpenAIApiBaseUrl(baseUrl) || isOpenAICodexBaseUrl(baseUrl);
-	return false;
-}
-function resolveSessionHeaders(params) {
-	if (!params.sessionId || !usesKnownNativeOpenAIRoute(params.provider, params.baseUrl)) return;
-	const sessionId = normalizeIdentityValue(params.sessionId);
-	if (!sessionId) return;
-	return {
-		"x-client-request-id": sessionId,
-		"x-genesis-session-id": sessionId
-	};
-}
-function resolveOpenAITransportTurnState(ctx) {
-	const sessionHeaders = resolveSessionHeaders({
-		provider: ctx.provider,
-		baseUrl: ctx.model?.baseUrl,
-		sessionId: ctx.sessionId
-	});
-	if (!sessionHeaders) return;
-	const turnId = normalizeIdentityValue(ctx.turnId);
-	const attempt = String(Math.max(1, ctx.attempt));
-	return {
-		headers: {
-			...sessionHeaders,
-			"x-genesis-turn-id": turnId,
-			"x-genesis-turn-attempt": attempt
-		},
-		metadata: {
-			genesis_session_id: sessionHeaders["x-genesis-session-id"] ?? "",
-			genesis_turn_id: turnId,
-			genesis_turn_attempt: attempt,
-			genesis_transport: ctx.transport
-		}
-	};
-}
-function resolveOpenAIWebSocketSessionPolicy(ctx) {
-	if (!usesKnownNativeOpenAIRoute(ctx.provider, ctx.model?.baseUrl)) return;
-	return {
-		headers: resolveSessionHeaders({
-			provider: ctx.provider,
-			baseUrl: ctx.model?.baseUrl,
-			sessionId: ctx.sessionId
-		}),
-		degradeCooldownMs: DEFAULT_OPENAI_WS_DEGRADE_COOLDOWN_MS
-	};
-}
-//#endregion
-export { resolveOpenAIWebSocketSessionPolicy as n, resolveOpenAITransportTurnState as t };

package/dist/trash-CVoAJSAx.js

@@ -1,24 +0,0 @@
-import { i as runExec } from "./exec-BbrLAvgI.js";
-import { i as generateSecureToken } from "./secure-random-XRbPM_Nv.js";
-import "./browser-node-runtime-CrigB5UH.js";
-import "./browser-security-runtime-bMw-CyNH.js";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-//#region extensions/browser/src/browser/trash.ts
-async function movePathToTrash(targetPath) {
-	try {
-		await runExec("trash", [targetPath], { timeoutMs: 1e4 });
-		return targetPath;
-	} catch {
-		const trashDir = path.join(os.homedir(), ".Trash");
-		fs.mkdirSync(trashDir, { recursive: true });
-		const base = path.basename(targetPath);
-		let dest = path.join(trashDir, `${base}-${Date.now()}`);
-		if (fs.existsSync(dest)) dest = path.join(trashDir, `${base}-${Date.now()}-${generateSecureToken(6)}`);
-		fs.renameSync(targetPath, dest);
-		return dest;
-	}
-}
-//#endregion
-export { movePathToTrash as t };

package/dist/tts-B5G7JHka.js

@@ -1,64 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
-import { i as assertOkOrThrowProviderError } from "./provider-http-errors-CHlOQSL-.js";
-import { a as postJsonRequest } from "./shared-dK9azfzw.js";
-import "./provider-http-jBjkpqsS.js";
-import "./speech-BaBZPcqn.js";
-import { t as XAI_BASE_URL } from "./model-definitions-DAfZ2fCD.js";
-import "./api-j3Hir2UT.js";
-//#region extensions/xai/tts.ts
-const XAI_TTS_VOICES = [
-	"eve",
-	"ara",
-	"rex",
-	"sal",
-	"leo",
-	"una"
-];
-function normalizeXaiTtsBaseUrl(baseUrl) {
-	const trimmed = baseUrl?.trim();
-	if (!trimmed) return XAI_BASE_URL;
-	return trimmed.replace(/\/+$/, "");
-}
-function isValidXaiTtsVoice(voice, baseUrl) {
-	const normalizedBase = normalizeXaiTtsBaseUrl(baseUrl ?? process.env.XAI_BASE_URL);
-	const host = normalizedBase.includes("://") ? new URL(normalizedBase).hostname : normalizedBase;
-	if (!(host === "api.x.ai" || host === "api.grok.x.ai")) return true;
-	return XAI_TTS_VOICES.includes(voice);
-}
-function normalizeXaiLanguageCode(value) {
-	const trimmed = normalizeOptionalString(value);
-	if (!trimmed) return;
-	const normalized = trimmed.toLowerCase();
-	if (normalized === "auto" || /^[a-z]{2,3}(?:-[a-z]{2,4})?$/.test(normalized)) return normalized;
-	throw new Error(`xAI language must be "auto" or a BCP-47 tag (e.g. "en", "pt-br", "zh-cn"); got: ${normalized}`);
-}
-async function xaiTTS(params) {
-	const { text, apiKey, baseUrl, voiceId, language: rawLanguage, speed, responseFormat = "mp3", timeoutMs } = params;
-	const language = normalizeXaiLanguageCode(rawLanguage) ?? "en";
-	if (!isValidXaiTtsVoice(voiceId, baseUrl)) throw new Error(`Invalid voice: ${voiceId}`);
-	const { response, release } = await postJsonRequest({
-		url: `${normalizeXaiTtsBaseUrl(baseUrl)}/tts`,
-		headers: new Headers({
-			Authorization: `Bearer ${apiKey}`,
-			"Content-Type": "application/json"
-		}),
-		body: {
-			text,
-			voice_id: voiceId,
-			language,
-			output_format: { codec: responseFormat },
-			...speed != null && { speed }
-		},
-		timeoutMs,
-		fetchFn: fetch,
-		auditContext: "xai tts"
-	});
-	try {
-		await assertOkOrThrowProviderError(response, "xAI TTS API error");
-		return Buffer.from(await response.arrayBuffer());
-	} finally {
-		await release();
-	}
-}
-//#endregion
-export { xaiTTS as a, normalizeXaiTtsBaseUrl as i, isValidXaiTtsVoice as n, normalizeXaiLanguageCode as r, XAI_TTS_VOICES as t };