@xopcai/xopc 0.0.269 → 0.0.272

package/dist/src/tunnel/frpc-release.d.ts

@@ -0,0 +1,27 @@
+export declare const FRPC_VERSION = "0.62.1";
+export declare const FRPC_RELEASES: {
+    readonly darwin_amd64: {
+        readonly archive: "f951a5aa727a4880f32753ba3c41ecc9dee38a63658760354011e71ea83db995";
+        readonly binary: "5ce5258b6ff1a232e9eb8e29247a55badb127e7fc66b5a58c299b442aba2bcb2";
+    };
+    readonly darwin_arm64: {
+        readonly archive: "f9fc616d994a87d790504da21c2f942cd4224637d9ade9a67482f3c23c7f2432";
+        readonly binary: "49afde483f55927c3eeac9141cae82857cb2f15b9e9d55f4ac45378e761eabcc";
+    };
+    readonly linux_amd64: {
+        readonly archive: "dcf1c62e5862543b6686a8e4c2f430ef636ac33306167f377e7272875020c4d3";
+        readonly binary: "030bff369048a49fce09e44f96e71fab36522394675ab10b2e684c9e3cc0aa26";
+    };
+    readonly linux_arm64: {
+        readonly archive: "94c98c19ce181f8e09e0d0cb79c278c31e9ec936eb713826a1ddf4995e7c2155";
+        readonly binary: "3f900ac9b035aac50b117ce5f7c450ca073d3e453448783979e978dc57bc39a9";
+    };
+    readonly windows_amd64: {
+        readonly archive: "a12e3b36b81232ad9888b43519a6dbcacc5c8def52f3a6c6e95d4fae6a373c5d";
+        readonly binary: "14cd52ca87fea607852b3a8e194146eeabe6ce87976cd1fc6327b74caebb6c77";
+    };
+    readonly windows_arm64: {
+        readonly archive: "da9e79e7cacc5570631196fae2f9e50ae5202521aa8abaf2e6de85b1778086b9";
+        readonly binary: "14b1b4bdd75228dc29dbc3ca264602911242a0e60cb0acb3311eb4926d50cb4b";
+    };
+};

package/dist/src/tunnel/frpc-release.js

@@ -0,0 +1,30 @@
+//#region src/tunnel/frpc-release.ts
+const FRPC_VERSION = "0.62.1";
+const FRPC_RELEASES = {
+	"darwin_amd64": {
+		"archive": "f951a5aa727a4880f32753ba3c41ecc9dee38a63658760354011e71ea83db995",
+		"binary": "5ce5258b6ff1a232e9eb8e29247a55badb127e7fc66b5a58c299b442aba2bcb2"
+	},
+	"darwin_arm64": {
+		"archive": "f9fc616d994a87d790504da21c2f942cd4224637d9ade9a67482f3c23c7f2432",
+		"binary": "49afde483f55927c3eeac9141cae82857cb2f15b9e9d55f4ac45378e761eabcc"
+	},
+	"linux_amd64": {
+		"archive": "dcf1c62e5862543b6686a8e4c2f430ef636ac33306167f377e7272875020c4d3",
+		"binary": "030bff369048a49fce09e44f96e71fab36522394675ab10b2e684c9e3cc0aa26"
+	},
+	"linux_arm64": {
+		"archive": "94c98c19ce181f8e09e0d0cb79c278c31e9ec936eb713826a1ddf4995e7c2155",
+		"binary": "3f900ac9b035aac50b117ce5f7c450ca073d3e453448783979e978dc57bc39a9"
+	},
+	"windows_amd64": {
+		"archive": "a12e3b36b81232ad9888b43519a6dbcacc5c8def52f3a6c6e95d4fae6a373c5d",
+		"binary": "14cd52ca87fea607852b3a8e194146eeabe6ce87976cd1fc6327b74caebb6c77"
+	},
+	"windows_arm64": {
+		"archive": "da9e79e7cacc5570631196fae2f9e50ae5202521aa8abaf2e6de85b1778086b9",
+		"binary": "14b1b4bdd75228dc29dbc3ca264602911242a0e60cb0acb3311eb4926d50cb4b"
+	}
+};
+//#endregion
+export { FRPC_RELEASES, FRPC_VERSION };

package/dist/src/tunnel/gateway-lifecycle.js

@@ -3,6 +3,8 @@ import { init_logger } from "../utils/logger.js";
 import { resolveGatewayEffectiveHost } from "../config/gateway-bind.js";
 import { resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl } from "./env.js";
 import { getTunnelService } from "./tunnel-service.js";
+import { resolveGatewayAuth } from "../gateway/auth.js";
+import { requireTunnelGatewayToken } from "./auth-policy.js";
 import { hasValidTunnelConsent } from "./consent.js";
 import { resolveFrpSubdomainHost } from "./frp-subdomain-host.js";
 import { fetchTunnelWellKnown } from "./well-known.js";
@@ -99,7 +101,8 @@ async function maybeAutoStartTunnelFromConfig(config, gatewayToken) {
 	const port = (config.gateway ?? {}).port ?? 18790;
 	const host = resolveGatewayEffectiveHost(config);
 	await configureTunnelFromGatewayConfig(config);
-	if (!gatewayToken) {
+	const resolvedAuth = resolveGatewayAuth({ authConfig: config.gateway?.auth });
+	if (resolvedAuth.mode !== "token" || !gatewayToken?.trim()) {
 		log.warn({ phase: "tunnel_autostart" }, "tunnel.autoStart is enabled but gateway auth token is unavailable (auth mode may be none)");
 		return;
 	}
@@ -113,7 +116,10 @@ async function maybeAutoStartTunnelFromConfig(config, gatewayToken) {
 		return;
 	}
 	try {
-		await tunnel.start(port, gatewayToken);
+		await tunnel.start(port, requireTunnelGatewayToken({
+			mode: resolvedAuth.mode,
+			token: gatewayToken
+		}));
 		log.info({
 			phase: "tunnel_autostart",
 			host,

package/dist/src/tunnel/index.js

@@ -1,5 +1,6 @@
 import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
-import { FRPC_VERSION, clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
+import { FRPC_VERSION } from "./frpc-release.js";
+import { clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
 import { TUNNEL_REGISTRATION_SECRET_REQUIRED_CODE, TunnelRegistrationSecretError, getTunnelRegistrationSecretMeta, isLocalDevelopmentTunnelBroker, isMaskedTunnelSecretPatchValue, resolveOptionalTunnelRegistrationSecret, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, tunnelRegistrationSecretRequiredMessage } from "./env.js";
 import { loadTunnelState, resolveTunnelStatePath, saveTunnelState } from "./tunnel-state.js";
 import { logTunnelAudit } from "./tunnel-audit.js";

package/dist/src/tunnel/registration-proof.d.ts

@@ -0,0 +1,19 @@
+/** Canonical v2 registration proof, shared with the Broker protocol test vectors. */
+export declare function createTunnelRegistrationProof(input: {
+    brokerUrl: string;
+    platform: string;
+    gatewayVersion: string;
+    preferredSubdomain?: string;
+    recoveryToken?: string;
+}): {
+    version: number;
+    gatewayId: string;
+    publicKey: string;
+    platform: string;
+    gatewayVersion: string;
+    preferredSubdomain: string;
+    recoveryToken: string;
+    nonce: string;
+    expiresAt: number;
+    signature: string;
+};

package/dist/src/tunnel/registration-proof.js

@@ -0,0 +1,37 @@
+import { getGatewayIdentityPublicKeyRaw, getOrCreateGatewayIdentity, signGatewayPayload } from "../storage/sqlite/gateway-identity-repository.js";
+import { randomBytes } from "node:crypto";
+//#region src/tunnel/registration-proof.ts
+/** Canonical v2 registration proof, shared with the Broker protocol test vectors. */
+function createTunnelRegistrationProof(input) {
+	const identity = getOrCreateGatewayIdentity();
+	const publicKey = getGatewayIdentityPublicKeyRaw(identity);
+	const nonce = randomBytes(24).toString("base64url");
+	const expiresAt = Date.now() + 12e4;
+	const audience = input.brokerUrl.replace(/\/+$/, "");
+	const payload = JSON.stringify([
+		"xopc-tunnel-registration-v2",
+		audience,
+		identity.id,
+		publicKey,
+		input.platform,
+		input.gatewayVersion,
+		input.preferredSubdomain ?? "",
+		input.recoveryToken ?? "",
+		nonce,
+		expiresAt
+	]);
+	return {
+		version: 2,
+		gatewayId: identity.id,
+		publicKey,
+		platform: input.platform,
+		gatewayVersion: input.gatewayVersion,
+		preferredSubdomain: input.preferredSubdomain,
+		recoveryToken: input.recoveryToken,
+		nonce,
+		expiresAt,
+		signature: signGatewayPayload(payload)
+	};
+}
+//#endregion
+export { createTunnelRegistrationProof };

package/dist/src/tunnel/tunnel-persist.js

@@ -8,6 +8,7 @@ function persistedFromRegistration(registration) {
 		frpcAuthToken: registration.frpc.authToken,
 		registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
 		enabled: true,
+		frpcSubdomain: registration.frpc.subdomain,
 		frpcServerAddr: registration.frpc.serverAddr,
 		frpcServerPort: registration.frpc.serverPort,
 		proxyName: registration.frpc.proxyName,
@@ -16,13 +17,14 @@ function persistedFromRegistration(registration) {
 }
 /** Rebuild registration from disk when Broker row is still valid (stop without deregister). */
 function registrationFromPersisted(persisted) {
-	if (!persisted.frpcAuthToken || !persisted.frpcServerAddr || !persisted.frpcServerPort || !persisted.proxyName) return null;
+	if (!persisted.frpcSubdomain || !persisted.frpcAuthToken || !persisted.frpcServerAddr || !persisted.frpcServerPort || !persisted.proxyName) return null;
 	return {
 		tunnelId: persisted.tunnelId,
 		tunnelToken: persisted.tunnelToken,
 		subdomain: persisted.subdomain,
 		publicUrl: persisted.publicUrl,
 		frpc: {
+			subdomain: persisted.frpcSubdomain,
 			serverAddr: persisted.frpcServerAddr,
 			serverPort: persisted.frpcServerPort,
 			authToken: persisted.frpcAuthToken,

package/dist/src/tunnel/tunnel-service.d.ts

@@ -37,6 +37,7 @@ export declare class TunnelService extends EventEmitter {
     private spawnAndWait;
     private scheduleReconnect;
     private runReconnectLoop;
+    private heartbeatGeneration;
     private startHeartbeat;
     private clearHeartbeat;
 }

package/dist/src/tunnel/tunnel-service.js

@@ -1,9 +1,9 @@
 import { PACKAGE_VERSION, init_package_version } from "../package-version.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
+import { TunnelBrokerClient, TunnelBrokerError, resolveBrokerApiBase } from "./broker-client.js";
 import { clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
-import { writeFrpcConfig } from "./frpc-config.js";
+import { removeFrpcConfig, writeFrpcConfig } from "./frpc-config.js";
 import { spawnFrpcProcess } from "./frpc-process.js";
 import { TunnelRegistrationSecretError } from "./env.js";
 import { canResumePersistedTunnel, persistedFromRegistration, registrationFromPersisted } from "./tunnel-persist.js";
@@ -127,7 +127,7 @@ var TunnelService = class extends EventEmitter {
 		saveTunnelState(state);
 		this.setStartPhase("registering", { publicUrl: registration.publicUrl });
 		try {
-			const configPath = writeFrpcConfig(registration, gatewayPort, "127.0.0.1", "http");
+			const configPath = writeFrpcConfig(registration, gatewayPort, "127.0.0.1");
 			this.setStartPhase("starting_frpc", { publicUrl: registration.publicUrl });
 			await this.spawnAndWait(frpcBin, configPath, broker, state, registration.heartbeatIntervalMs);
 		} catch (err) {
@@ -161,6 +161,7 @@ var TunnelService = class extends EventEmitter {
 		let released = false;
 		const persisted = loadTunnelState();
 		const cfg = this.serviceConfig;
+		if (persisted) removeFrpcConfig(persisted.tunnelId);
 		if (release && persisted && cfg) {
 			const broker = new TunnelBrokerClient(resolveBrokerApiBase(cfg.brokerUrl));
 			try {
@@ -206,6 +207,7 @@ var TunnelService = class extends EventEmitter {
 				return resumed;
 			}
 		} catch (err) {
+			if (!(err instanceof TunnelBrokerError) || err.status !== 410) throw err;
 			log.info({
 				err,
 				tunnelId: persisted.tunnelId,
@@ -218,7 +220,7 @@ var TunnelService = class extends EventEmitter {
 			registrationSecret: cfg.registrationSecret,
 			gatewayVersion: PACKAGE_VERSION,
 			platform: platformLabel(),
-			gatewayTokenHash: hashGatewayToken(gatewayToken),
+			recoveryToken: persisted?.tunnelToken,
 			preferredSubdomain: persisted?.subdomain
 		});
 	}
@@ -285,19 +287,37 @@ var TunnelService = class extends EventEmitter {
 			}
 		}
 	}
+	heartbeatGeneration = 0;
 	startHeartbeat(broker, state, intervalMs) {
 		this.clearHeartbeat();
+		const generation = this.heartbeatGeneration;
+		let pending = false;
 		const tick = async () => {
+			if (pending || this.stopping || generation !== this.heartbeatGeneration) return;
+			pending = true;
 			try {
 				await broker.heartbeat(state.tunnelId, state.tunnelToken);
-				this.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+				if (generation === this.heartbeatGeneration) this.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
 			} catch (err) {
 				log.warn({
 					err,
 					tunnelId: state.tunnelId
 				}, "Tunnel heartbeat failed");
-				if (this.stopping) return;
+				if (this.stopping || generation !== this.heartbeatGeneration) return;
+				if (!(err instanceof TunnelBrokerError) || ![
+					401,
+					403,
+					410
+				].includes(err.status)) return;
 				this.clearHeartbeat();
+				if (err.status === 401 || err.status === 403) {
+					await this.stop();
+					this.lastError = "TUNNEL_AUTH_REVOKED";
+					this.state = "error";
+					this.emit("tunnel:error", this.lastError);
+					return;
+				}
+				const renewalGeneration = this.heartbeatGeneration;
 				const ctx = this.startContext;
 				const cfg = this.serviceConfig;
 				if (!ctx || !cfg) return;
@@ -308,25 +328,32 @@ var TunnelService = class extends EventEmitter {
 						registrationSecret: cfg.registrationSecret,
 						gatewayVersion: PACKAGE_VERSION,
 						platform: platformLabel(),
-						gatewayTokenHash: hashGatewayToken(ctx.gatewayToken),
+						recoveryToken: state.tunnelToken,
 						preferredSubdomain: state.subdomain
 					});
+					if (this.stopping || renewalGeneration !== this.heartbeatGeneration) return;
 					const next = persistedFromRegistration(registration);
+					removeFrpcConfig(state.tunnelId);
 					saveTunnelState(next);
 					const frpcBin = await ensureFrpcBinary();
-					const configPath = writeFrpcConfig(registration, ctx.gatewayPort, "127.0.0.1", "http");
+					const configPath = writeFrpcConfig(registration, ctx.gatewayPort, "127.0.0.1");
 					await this.spawnAndWait(frpcBin, configPath, broker, next, registration.heartbeatIntervalMs);
 				} catch (reErr) {
+					if (this.stopping || renewalGeneration !== this.heartbeatGeneration) return;
+					if (reErr instanceof TunnelBrokerError && [401, 403].includes(reErr.status)) await this.stop();
 					this.lastError = reErr instanceof Error ? reErr.message : String(reErr);
 					this.state = "error";
 					this.emit("tunnel:error", this.lastError);
 				}
+			} finally {
+				pending = false;
 			}
 		};
 		tick();
 		this.heartbeatTimer = setInterval(() => void tick(), intervalMs);
 	}
 	clearHeartbeat() {
+		this.heartbeatGeneration += 1;
 		if (this.heartbeatTimer) {
 			clearInterval(this.heartbeatTimer);
 			this.heartbeatTimer = null;

package/dist/src/tunnel/tunnel-state.js

@@ -1,7 +1,7 @@
 import { resolveStateDir } from "../config/paths-state.js";
 import { init_paths } from "../config/paths.js";
 import { join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 //#region src/tunnel/tunnel-state.ts
 init_paths();
 const TUNNEL_STATE_FILE = "tunnel.json";
@@ -22,8 +22,15 @@ function loadTunnelState() {
 }
 function saveTunnelState(state) {
 	const path = resolveTunnelStatePath();
-	mkdirSync(resolveStateDir(), { recursive: true });
-	writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	mkdirSync(resolveStateDir(), {
+		recursive: true,
+		mode: 448
+	});
+	chmodSync(resolveStateDir(), 448);
+	const temporary = `${path}.${process.pid}.tmp`;
+	writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 384 });
+	chmodSync(temporary, 384);
+	renameSync(temporary, path);
 }
 function updateTunnelState(patch) {
 	const current = loadTunnelState();
@@ -36,8 +43,7 @@ function updateTunnelState(patch) {
 	return next;
 }
 function clearTunnelState() {
-	const path = resolveTunnelStatePath();
-	if (existsSync(path)) writeFileSync(path, "{}\n", "utf8");
+	rmSync(resolveTunnelStatePath(), { force: true });
 }
 //#endregion
 export { clearTunnelState, loadTunnelState, resolveTunnelStatePath, saveTunnelState, updateTunnelState };

package/dist/src/tunnel/tunnel-types.d.ts

@@ -21,6 +21,7 @@ export type TunnelRegistration = {
         serverPort: number;
         authToken: string;
         proxyName: string;
+        subdomain: string;
     };
     expiresAt: string;
     heartbeatIntervalMs: number;
@@ -34,6 +35,7 @@ export type PersistedTunnelState = {
     registeredAt: string;
     enabled?: boolean;
     /** Saved on register so stop/start can resume without re-registering. */
+    frpcSubdomain?: string;
     frpcServerAddr?: string;
     frpcServerPort?: number;
     proxyName?: string;

package/dist/src/tunnel/well-known.js

@@ -16,9 +16,13 @@ async function fetchTunnelWellKnown(brokerUrl) {
 	const origin = brokerOrigin(brokerUrl);
 	if (cached && cached.origin === origin && Date.now() - cached.fetchedAt < CACHE_TTL_MS) return cached.config;
 	const url = `${origin}/.well-known/tunnel-config`;
-	const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+	const res = await fetch(url, {
+		redirect: "error",
+		signal: AbortSignal.timeout(1e4)
+	});
 	if (!res.ok) throw new Error(`Tunnel well-known fetch failed: ${res.status} ${res.statusText}`);
 	const body = await res.json();
+	if (new URL(body.brokerUrl).origin !== origin) throw new Error("Broker discovery cannot redirect registration credentials to another origin");
 	cached = {
 		origin,
 		config: body,

package/dist/src/user-context/config.js

@@ -20,7 +20,7 @@ var init_config = __esmMin((() => {
 		minMessagesBeforeCompact: 10,
 		keepRecentTokens: 2e4,
 		recentTurnsPreserve: 3,
-		summaryMaxTokens: 2e3,
+		summaryMaxTokens: 8e3,
 		summaryChunkTokens: 24e3,
 		summaryTimeoutMs: 18e4,
 		summaryRetries: 2,
@@ -37,7 +37,7 @@ var init_config = __esmMin((() => {
 		minMessagesBeforeCompact: z.number().int().min(2).default(10),
 		keepRecentTokens: z.number().int().min(1e3).default(2e4),
 		recentTurnsPreserve: z.number().int().min(1).max(12).default(3),
-		summaryMaxTokens: z.number().int().min(256).default(2e3),
+		summaryMaxTokens: z.number().int().min(256).default(8e3),
 		summaryChunkTokens: z.number().int().min(1e3).default(24e3),
 		summaryTimeoutMs: z.number().int().min(1e3).max(6e5).default(18e4),
 		summaryRetries: z.number().int().min(0).max(5).default(2),

package/dist/src/utils/logger/redact.js

@@ -56,6 +56,7 @@ var init_redact = __esmMin((() => {
 	DEFAULT_REDACT_PATTERNS = [
 		/\b[A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD)\b\s*[=:]\s*(["']?)([^\s"'\\]+)\1/gi,
 		/"(?:apiKey|token|secret|password|passwd|accessToken|refreshToken|privateKey)"\s*:\s*"([^"]+)"/gi,
+		/(?:__Host-xopc-session|xopc-local-session)=([A-Za-z0-9_-]{43})/g,
 		/Authorization\s*[:=]\s*Bearer\s+([A-Za-z0-9._\-+=]+)/gi,
 		/\b(sk-[A-Za-z0-9_-]{8,})\b/gi,
 		/\b(ghp_[A-Za-z0-9]{20,})\b/gi,
@@ -76,6 +77,9 @@ var init_redact = __esmMin((() => {
 		"privatekey",
 		"private_key",
 		"authorization",
+		"cookie",
+		"set-cookie",
+		"signedpayload",
 		"credential",
 		"credentials"
 	]);

package/dist/src/voice/dashscope/streaming-stt-session.js

@@ -92,6 +92,7 @@ async function openDashScopeStreamingStt(request) {
 					sample_rate: request.inputFormat.sampleRate,
 					semantic_punctuation_enabled: false,
 					max_sentence_silence: request.turnDetection.silenceDurationMs,
+					heartbeat: true,
 					...request.language && request.language !== "auto" ? { language_hints: [request.language] } : {}
 				},
 				input: request.prompt ? { context: [{

package/dist/src/voice/dashscope/streaming-tts-stream.d.ts

@@ -4,6 +4,7 @@ export interface DashScopeStreamingTtsRequest {
     baseUrl?: string;
     model: string;
     voice: string;
+    volume?: number;
     text: string;
     instructions?: string;
     signal: AbortSignal;

package/dist/src/voice/dashscope/streaming-tts-stream.js

@@ -7,6 +7,7 @@ import { setTimeout as setTimeout$1 } from "node:timers/promises";
 init_logger();
 const { WebSocket } = createRequire(import.meta.url)("ws");
 const DEFAULT_REALTIME_URL = "wss://dashscope.aliyuncs.com/api-ws/v1/realtime";
+const DEFAULT_REALTIME_VOLUME = 100;
 const log = createLogger("TTS:DashScope");
 var TtsHandshakeError = class extends Error {
 	constructor(statusCode, retryAfterMs) {
@@ -46,6 +47,12 @@ function event(type, extra = {}) {
 	});
 }
 async function openDashScopeStreamingTts(request) {
+	const volume = request.volume ?? DEFAULT_REALTIME_VOLUME;
+	if (!Number.isInteger(volume) || volume < 0 || volume > 100) throw new Error("DashScope realtime TTS volume must be an integer from 0 to 100");
+	request = {
+		...request,
+		volume
+	};
 	const deadline = Date.now() + request.timeoutMs;
 	for (let attempt = 1;; attempt += 1) {
 		request.signal.throwIfAborted();
@@ -138,6 +145,7 @@ async function openStreamingTtsAttempt(request) {
 				language_type: "Auto",
 				response_format: "pcm",
 				sample_rate: 24e3,
+				volume: request.volume,
 				...request.instructions ? {
 					instructions: request.instructions,
 					optimize_instructions: false

package/dist/src/voice/realtime/agentBroker.js

@@ -101,7 +101,7 @@ var DurableVoiceAgentBroker = class {
 				const event = eventData(delivery);
 				if (!event) continue;
 				yield event;
-				if (event.type === "stream_end") {
+				if (event.type === "run_end" || event.type === "stream_end") {
 					this.runByTask.delete(taskId);
 					return;
 				}

package/dist/src/voice/realtime/agentEngine.js

@@ -284,7 +284,7 @@ function createAgentVoiceEngine(options) {
 					toolName: event.payload.toolName.slice(0, 256),
 					status: event.type === "tool_start" ? "running" : event.payload.status === "error" ? "failed" : "completed"
 				});
-				if (event.type === "stream_end") {
+				if (event.type === "run_end" || event.type === "stream_end") {
 					const status = event.payload?.status;
 					send("task.done", {
 						taskId: task.taskId,

package/dist/src/voice/realtime/pcm-output-gain.d.ts

@@ -0,0 +1,2 @@
+/** Raise conversational PCM output without changing the device's system volume. */
+export declare function applyVoiceOutputGain(bytes: Uint8Array): Uint8Array;

package/dist/src/voice/realtime/pcm-output-gain.js

@@ -0,0 +1,16 @@
+//#region src/voice/realtime/pcm-output-gain.ts
+const OUTPUT_GAIN = 1.5;
+/** Raise conversational PCM output without changing the device's system volume. */
+function applyVoiceOutputGain(bytes) {
+	if (bytes.byteLength % 2 !== 0) throw new Error("Voice output must contain aligned PCM samples");
+	const output = new Uint8Array(bytes.byteLength);
+	const inputView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const outputView = new DataView(output.buffer);
+	for (let offset = 0; offset < bytes.byteLength; offset += 2) {
+		const amplified = Math.round(inputView.getInt16(offset, true) * OUTPUT_GAIN);
+		outputView.setInt16(offset, Math.max(-32768, Math.min(32767, amplified)), true);
+	}
+	return output;
+}
+//#endregion
+export { applyVoiceOutputGain };

package/dist/src/voice/realtime/runtime.d.ts

@@ -28,6 +28,7 @@ export declare class VoiceRealtimeRuntime {
     handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): boolean;
     hasConversation(sessionKey: string): boolean;
     cancelSession(sessionId: string, ticket: string, principalId: string): Promise<boolean>;
+    disconnectPrincipal(principalId: string): void;
     close(): void;
     private releaseConversationReservation;
     private consumeTicket;

package/dist/src/voice/realtime/runtime.js

@@ -15,6 +15,7 @@ import { VOICE_REALTIME_HEARTBEAT_INTERVAL_MS, VOICE_REALTIME_MAX_BINARY_FRAME_B
 import { createAgentVoiceEngine } from "./agentEngine.js";
 import { resolveOmniRoute } from "./omniRoute.js";
 import { createOmniVoiceEngine } from "./omniEngine.js";
+import { applyVoiceOutputGain } from "./pcm-output-gain.js";
 import { createRequire } from "node:module";
 import crypto from "node:crypto";
 //#region src/voice/realtime/runtime.ts
@@ -301,6 +302,13 @@ var VoiceRealtimeRuntime = class {
 		await active.shutdown();
 		return true;
 	}
+	disconnectPrincipal(principalId) {
+		for (const [key, claim] of this.tickets) if (claim.principalId === principalId) {
+			this.tickets.delete(key);
+			this.releaseConversationReservation(claim);
+		}
+		for (const socket of this.socketsByPrincipal.get(principalId) ?? []) socket.terminate();
+	}
 	close() {
 		if (this.closed) return;
 		this.closed = true;
@@ -364,6 +372,10 @@ var VoiceRealtimeRuntime = class {
 		};
 		const detachPrincipal = () => {
 			if (!claim) return;
+			if (this.options.isPrincipalActive?.(claim.principalId) === false) {
+				socket.terminate();
+				return;
+			}
 			const sockets = this.socketsByPrincipal.get(claim.principalId);
 			sockets?.delete(socket);
 			if (sockets?.size === 0) this.socketsByPrincipal.delete(claim.principalId);
@@ -394,6 +406,10 @@ var VoiceRealtimeRuntime = class {
 		const startTimer = setTimeout(() => socket.close(4401, "Voice session start timeout"), VOICE_REALTIME_START_TIMEOUT_MS);
 		const lifecycleTimer = setInterval(() => {
 			if (!claim) return;
+			if (this.options.isPrincipalActive?.(claim.principalId) === false) {
+				socket.terminate();
+				return;
+			}
 			if (context?.isCurrent && !context.isCurrent()) {
 				invalidateContext();
 				return;
@@ -417,7 +433,8 @@ var VoiceRealtimeRuntime = class {
 		};
 		const authenticate = async (message) => {
 			const consumed = this.consumeTicket(message.payload.ticket, message.payload.sessionId);
-			if (!consumed) {
+			if (!consumed || this.options.isPrincipalActive?.(consumed.principalId) === false) {
+				if (consumed) this.releaseConversationReservation(consumed);
 				socket.close(4401, "Invalid voice session ticket");
 				return;
 			}
@@ -465,8 +482,9 @@ var VoiceRealtimeRuntime = class {
 				const sendAudio = (responseId, bytes) => {
 					if (socket.bufferedAmount > 1024 * 1024) throw new Error("Voice client audio backpressure limit exceeded");
 					if (closed || socket.readyState !== WebSocketState.OPEN) return;
-					for (let offset = 0; offset < bytes.byteLength; offset += 960) {
-						const audio = bytes.subarray(offset, offset + 960);
+					const amplified = applyVoiceOutputGain(bytes);
+					for (let offset = 0; offset < amplified.byteLength; offset += 960) {
+						const audio = amplified.subarray(offset, offset + 960);
 						if (audio.byteLength !== 960) throw new Error("Realtime output must align to 20 ms PCM frames");
 						socket.send(encodeVoiceAudioFrame({
 							connectionEpoch: consumed.connectionEpoch,

package/dist/src/voice/realtime/runtime.types.d.ts

@@ -41,6 +41,7 @@ export interface ResolvedStreamingTts {
     route: VoiceProviderRoute;
 }
 export interface VoiceRealtimeRuntimeOptions {
+    isPrincipalActive?: (principalId: string) => boolean;
     recordOmniTranscript?: (sessionKey: string, callId: string, entry: OmniTranscript, expectedSessionId: string) => Promise<void>;
     getConversationContext?: (sessionKey: string, expectedSessionId: string) => Promise<VoiceConversationContext>;
     getSessionIdentity?: (sessionKey: string) => Promise<string | undefined>;

package/dist/src/workflows/service/workflow-run-service.js

@@ -5,9 +5,9 @@ import { init_providers, resolveModel } from "../../providers/index.js";
 import { TaskRepository } from "../../tasks/task-repository.js";
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
-import { publishAutomationProductEvent } from "../../automations/product-events.js";
 import { TaskContextRepository } from "../../tasks/task-context-repository.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
+import { publishAutomationProductEvent } from "../../automations/product-events.js";
 import { resolveModelSelector } from "../../config/agent-model-intents.js";
 import { DelegateSubagentRunner } from "../../agent/workflow/subagent-runner.js";
 import { preflightWorkflowConnectors } from "../../connectors/workflow-preflight.js";
@@ -192,6 +192,7 @@ var WorkflowRunService = class {
 			agentId: params.agentId,
 			definitionId: params.definitionId,
 			definitionTitle: definition.title,
+			triggerSource: params.source.kind,
 			goal,
 			parentSessionKey: params.parentSessionKey,
 			projectId
@@ -387,6 +388,7 @@ var WorkflowRunService = class {
 			agentId: params.agentId,
 			definitionId: existing.run.definitionId,
 			definitionTitle: `${definition.title} replay`,
+			triggerSource: existing.run.source.kind,
 			goal,
 			parentSessionKey,
 			projectId

package/dist/src/workflows/service/workflow-session-bridge.d.ts

@@ -10,6 +10,7 @@ export interface PrepareWorkflowRunSessionParams {
     goal: string;
     parentSessionKey?: string;
     projectId?: string;
+    triggerSource?: string;
 }
 export interface PrepareWorkflowRunSessionResult {
     sessionKey: string;

package/dist/src/workflows/service/workflow-session-bridge.js

@@ -48,6 +48,7 @@ var WorkflowSessionBridge = class {
 				workflowRunId: params.runId,
 				workflowDefinitionId: params.definitionId,
 				workflowGoal: params.goal,
+				...params.triggerSource ? { triggerSource: params.triggerSource } : {},
 				...params.parentSessionKey ? { parentSessionKey: params.parentSessionKey } : {}
 			}
 		});