zigmini 0.9.0-beta.1 → 0.9.0-beta.3

package/src/hub.ts

@@ -13,7 +13,7 @@ import { isVersionCommand, VERSION_COMMAND } from "./version.ts";
 import { isUsageCommand, USAGE_COMMAND } from "./usage.ts";
 import { MessageReferenceError, referencedInput, resolveMessageReferences } from "./message-references.ts";
 import { readProfile } from "./profile.ts";
-import type { MessageGuard } from "./security-check.ts";
+import type { MessageGuard, SecurityChecker } from "./security-check.ts";
 import { SecurityRuntimeError, type SecurityReceipt } from "./security-allow.ts";
 import { nativeReplyEntry, type NativeReplyObserver } from "./reply-notifications.ts";
 import { notificationHistory } from "./notification-history.ts";
@@ -52,7 +52,7 @@ export interface HubOptions {
 	/** Where attached images live (`dir`, as this process sees it) and the same folder's path on the Mac, for the agent. */
 	media?: { dir: string; hostDir?: string };
 	now?: () => number;
-	rotation?: { maxAgeMs?: number; idleMs?: number; forceMaxBytes?: number; forceUpdateCompactions?: number };
+	rotation?: { maxAgeMs?: number; idleMs?: number; forceMaxBytes?: number; forceUpdateCompactions?: number; freshSessionCompactionFailures?: number };
 	/** Bug 152: bounded native ownership reconciliation; timers are injectable for deterministic tests. */
 	closeRecovery?: {
 		intervalMs?: number;
@@ -87,9 +87,62 @@ const COMPACTION_RECOVERY = {
 	context_budget: { action: "retry", message: "요약 결과가 대화 모델의 입력 한도에 맞지 않습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
 	stale: { action: "retry", message: "요약 중 대화가 바뀌었습니다. 최신 대화에서 다시 진행해 주세요." },
 	provider: { action: "retry", message: "원인을 해결한 뒤 다시 진행해 주세요." },
+	account_blocked: { action: "account", message: "요약 공급자의 계정 묶음이 요청을 보내지 않았습니다. 원인이 사용 한도인지 인증인지는 확정되지 않았습니다. 계정 상태를 확인하거나 다른 모델을 고른 뒤 다시 진행해 주세요." },
 } as const satisfies Record<CompactionFailureKind, { readonly action: string; readonly message: string }>;
 
-export type RotationReason = "manual" | "age" | ForcedRotationReason;
+/** Bug 223: the longest provider error a compaction failure log line keeps, after its sensitive values are removed. */
+export const COMPACTION_ERROR_MAX_CHARS = 512;
+
+/**
+ * Bug 223: the provider's own error text with every value the repository security check finds (tokens, keys,
+ * credentials, home paths, e-mail, internal addresses, device ids) replaced by [redacted], on one line, at most
+ * COMPACTION_ERROR_MAX_CHARS. The cause wording stays. Values are found before the text is cut.
+ */
+export function sanitizeProviderError(text: unknown, checker: Pick<SecurityChecker, "runtimeOccurrences">): string | null {
+	if (typeof text !== "string") return null;
+	const withoutPrivateKeys = text.replace(/-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----[\s\S]*?(?:-----END (?:[A-Z0-9]+ )*PRIVATE KEY-----|$)/g, "[redacted]");
+	const flat = withoutPrivateKeys.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, " ").replace(/\s+/g, " ").trim();
+	if (!flat) return null;
+	const spans = checker.runtimeOccurrences([flat])
+		.map((found) => [found.start ?? 0, found.end ?? flat.length] as const).sort((a, b) => a[0] - b[0]);
+	let kept = "";
+	let at = 0;
+	for (const [start, end] of spans) {
+		if (end <= at) continue;
+		if (start >= at) kept += `${flat.slice(at, start)}[redacted]`;
+		at = end;
+	}
+	kept += flat.slice(at);
+	return kept.length > COMPACTION_ERROR_MAX_CHARS ? `${kept.slice(0, COMPACTION_ERROR_MAX_CHARS)}…` : kept;
+}
+
+/**
+ * Bug 223: the fields of one gateway log line per failed blocking compaction. A provider/model the engine did not list
+ * or a malformed number never reaches the log. The provider error is kept only through sanitizeProviderError;
+ * errorMessage and other free text are never read.
+ */
+export function compactionFailureLog(failureKind: CompactionFailureKind, failure: unknown, knownModels: ReadonlySet<string>,
+	sanitize: (text: unknown) => string | null = () => null): Record<string, unknown> {
+	const fields = typeof failure === "object" && failure !== null ? failure as Record<string, unknown> : {};
+	const provider = typeof fields.provider === "string" ? fields.provider : "";
+	const model = typeof fields.model === "string" ? fields.model : "";
+	const listed = knownModels.has(`${provider}/${model}`);
+	const tokens = fields.inputTokens;
+	const retryAt = fields.retryAt;
+	return {
+		failureKind,
+		provider: listed ? provider : "unknown",
+		model: listed ? model : "unknown",
+		error: sanitize(fields.error) ?? "unknown",
+		inputTokens: typeof tokens === "number" && Number.isSafeInteger(tokens) && tokens >= 0 ? tokens : "unknown",
+		inputTokensSource: fields.inputTokensSource === "estimate" || fields.inputTokensSource === "provider" ? fields.inputTokensSource : "unknown",
+		requestSent: typeof fields.requestSent === "boolean" ? fields.requestSent : "unknown",
+		...(typeof retryAt === "number" && Number.isSafeInteger(retryAt) && retryAt > 0 && retryAt < 8.64e15
+			? { retryAt: new Date(retryAt).toISOString() } : {}),
+	};
+}
+
+export type RotationReason = "manual" | "age" | "compaction_failed" | ForcedRotationReason;
 /** Bug 72 proposal 4: limits that rotate a session even with works, updates, decisions or questions open. */
 export type ForcedRotationReason = "size" | "compactions";
 
@@ -106,6 +159,10 @@ export const ROTATION_HELD_LOG_MS = 6 * 60 * 60 * 1000;
 export const ROTATION_RETRY_MS = 30 * 60 * 1000;
 /** Bug 72: completed turns that must carry an unconsumed user input before an idle native releases it from the turn. */
 export const UNCONSUMED_INPUT_RELEASE_TURNS = 2;
+/** Bug 224: the engine's exact refusal of a prompt before accepting it while compaction is unfinished (RequiredCompactionError). */
+export const REQUIRED_COMPACTION_REFUSAL = "Context remains above the compaction threshold because compaction did not complete";
+/** Bug 224 (user decision 2026-10-29): failed compactions in a row of one session that open a fresh session. */
+export const FRESH_SESSION_COMPACTION_FAILURES = 2;
 
 /** Bug 72: one condition that now holds a conversation's session rotation. */
 export interface RotationBlocker {
@@ -147,6 +204,7 @@ function describeBlockers(blockers: readonly RotationBlocker[]): string {
 const HANDOFF_MAX_CHARS = 8000;
 const HANDOFF_LINE_CHARS = 600;
 const CONTEXT_OVERFLOW = /prompt is too long|context overflow/i;
+const COMPACTION_REQUIRED_MESSAGE = "대화 요약이 끝나지 않아 엔진이 이 메시지를 받지 않았습니다. 메시지는 기록에 남아 있고 자동으로 다시 보내지 않습니다. 요약 실패 원인을 해결하거나 '새 세션'을 눌러 주세요.";
 
 interface OpenResult {
 	sessionId: string;
@@ -189,6 +247,7 @@ interface ConvRuntime {
 	run: number;
 	rotating: boolean;
 	admitting: number;
+	promptAdmissions: Set<() => void>;
 	clientInputIdentity: boolean;
 	atomicQueuedResume: boolean;
 	/** `open_session` state.sessionId: the session file's own identity, which survives reconnects. */
@@ -659,6 +718,8 @@ export class Hub {
 
 	/** Whether the last model answer named a held switch; the next settled main turn re-reads it. */
 	private modelPending = false;
+	private readonly knownModels = new Set<string>();
+	private providerErrorChecker: SecurityChecker | null = null;
 
 	/** The models omo can use right now (its logged-in providers) and the one a conversation's session is on. */
 	async models(convId = "main"): Promise<ModelInfo> {
@@ -671,6 +732,7 @@ export class Hub {
 			omo.command<{ model?: OmoModel | null; thinkingLevel?: string; pendingModelSwitch?: { provider: string; id: string } | null }>("get_state", { sessionId }),
 		]);
 		const options = modelOptions(available.models ?? []);
+		for (const option of options) this.knownModels.add(`${option.provider}/${option.id}`);
 		const held = state.pendingModelSwitch;
 		const pending = held
 			? options.find((o) => o.provider === held.provider && o.id === held.id) ?? { provider: held.provider, id: held.id, name: held.id }
@@ -1185,7 +1247,8 @@ export class Hub {
 		if (!conv) throw new Error(`unknown_conversation:${convId}`);
 		const rt = this.rt(convId);
 		const forced = reason === "size" || reason === "compactions";
-		if (rt.rotating || this.rotationHeldFor(convId, forced)) throw new Error("turn_running");
+		const residue = this.residualTurn(convId, reason);
+		if (rt.rotating || (this.rotationHeldFor(convId, forced) && residue === null)) throw new Error("turn_running");
 		if (this.omoStatus !== "ready" || this.closeUncertain(convId)) throw new Error("session_ownership_unknown");
 		const generation = this.generation;
 		const from = conv.threadId;
@@ -1243,7 +1306,7 @@ export class Hub {
 				rt.sessionId !== sessionId ||
 				from !== source ||
 				this.store.lastSeq(convId, "message.user") !== admittedUser ||
-				this.rotationHeldFor(convId, forced)
+				(this.rotationHeldFor(convId, forced) && (residue === null || this.residualTurn(convId, reason) !== residue))
 			) {
 				throw new Error("turn_running");
 			}
@@ -1288,6 +1351,92 @@ export class Hub {
 		}
 	}
 
+	/**
+	 * Bug 224: a manual rotation may retire a session whose main turn left only residue: inputs nothing runs any more and
+	 * a work wake whose send already ended. Returns that residue's identity, or null when anything else holds. rotateSession
+	 * still proves the engine idle (no streaming, compaction, retry, queue or question) before it closes the session.
+	 */
+	private residualTurn(conv: string, reason: RotationReason): string | null {
+		if (reason !== "manual") return null;
+		const rt = this.rt(conv);
+		const holds = this.rotationHoldsFor(conv, false);
+		if (holds.length === 0 || this.store.pendingMainUsers(conv).length > 0) return null;
+		const residual = holds.every((hold) => hold.kind === "main_turn" &&
+			(hold.state === "unfinished_turn" || (hold.state === "waking" && rt.waking === null)));
+		if (!residual) return null;
+		const turn = this.store.mainTurn(conv);
+		return JSON.stringify({ turn: turn?.seq ?? null, inputs: turn?.inputs.map((input) => input.seq) ?? [], wake: rt.wake?.input.seq ?? null });
+	}
+
+	/**
+	 * Bug 224 (user decision 2026-10-29): FRESH_SESSION_COMPACTION_FAILURES failed compactions in a row open a fresh session
+	 * without asking the old one for anything. The old session is detached first, so its late events never reach this
+	 * conversation; stopping and closing it are best effort. Its file stays; the handoff names it and carries only the
+	 * recent exchange. Works, decisions and never-sent user input carry over as in any rotation; nothing is replayed.
+	 */
+	private openFreshSession(convId: string): void {
+		if (this.maintenanceId || this.omoStatus !== "ready") return;
+		const conv = this.store.getConversation(convId);
+		const rt = this.rt(convId);
+		if (!conv?.threadId || rt.rotating) return;
+		const from = conv.threadId;
+		const sessionId = rt.sessionId;
+		// Synchronous from the check above to the new thread, so no prompt or rotation interleaves; no latch is needed.
+		this.emit(convId, "session.transition", { active: true, label: "세션 교체 중" }, false);
+		try {
+			if (sessionId) this.retireScopedQuestions(convId, sessionId);
+			rt.running = false;
+			rt.durableId = null;
+			rt.run++;
+			this.finishRetirement(convId, {
+				sessionId: sessionId ?? "", sessionPath: from, from, reason: "compaction_failed",
+				handoff: this.buildHandoff(convId, "compaction_failed", from),
+			});
+			this.publishActivity(convId);
+		} finally {
+			this.emit(convId, "session.transition", { active: false, label: null }, false);
+		}
+		if (sessionId) void this.stopAbandonedSession(sessionId);
+		if (this.store.pendingMainUsers(convId).length > 0) void this.recover();
+		void this.notifyWorkUpdates(convId);
+	}
+
+	/** A detached session gets one abort and one close; it no longer routes to any conversation, so failures only log. */
+	private async stopAbandonedSession(sessionId: string): Promise<void> {
+		for (const command of ["abort", "close_session"] as const) {
+			try {
+				await this.requireOmo().command(command, { sessionId });
+			} catch (error) {
+				console.error(`abandoned session ${command} failed (${sessionId}): ${errorMessage(error)}`);
+			}
+		}
+	}
+
+	/** Bug 223: log with cached model identities; an unhealthy engine must never hold its own failure diagnostic. */
+	private async logCompactionFailure(failureKind: CompactionFailureKind, failure: unknown): Promise<void> {
+		// Loaded on first use: the security rules ship beside src/, and only a failure needs them.
+		if (!this.providerErrorChecker) this.providerErrorChecker = (await import("./security-check.ts")).defaultChecker();
+		const checker = this.providerErrorChecker;
+		console.error("compaction_failed", JSON.stringify(compactionFailureLog(failureKind, failure, this.knownModels,
+			(text) => sanitizeProviderError(text, checker))));
+	}
+
+	private freshSessionCompactionFailures(): number {
+		return this.options.rotation?.freshSessionCompactionFailures ?? FRESH_SESSION_COMPACTION_FAILURES;
+	}
+
+	/** Bug 224: failed blocking compactions since the last completed one in this session, one per native request id. */
+	private compactionFailuresInRow(conv: string): number {
+		const failed = new Set<string>();
+		for (const event of this.store.eventsAfter(conv, this.store.lastSeq(conv, "session.rotated")).reverse()) {
+			if (event.type !== "session.compaction") continue;
+			const data = event.data as { status?: string; requestId?: unknown };
+			if (data.status === "completed") break;
+			if (data.status === "failed" && typeof data.requestId === "string") failed.add(data.requestId);
+		}
+		return failed.size;
+	}
+
 	private closeUncertain(conv: string): boolean {
 		return this.store.lastSeq(conv, "session.close.unknown") >
 			Math.max(this.store.lastSeq(conv, "session.rotated"), this.store.lastSeq(conv, "session.close.resolved"));
@@ -1304,9 +1453,16 @@ export class Hub {
 
 	private finishRetirement(convId: string, retirement: SessionRetirement): void {
 		const rt = this.rt(convId);
-		const owner = this.ownerForConversation(convId, retirement.sessionId);
-		this.sessionToConv.delete(retirement.sessionId);
-		if (owner) this.releaseScopedUiOwner(owner);
+		for (const release of rt.promptAdmissions) release();
+		if (retirement.sessionId) {
+			const owner = this.ownerForConversation(convId, retirement.sessionId);
+			this.sessionToConv.delete(retirement.sessionId);
+			if (owner) this.releaseScopedUiOwner(owner);
+		}
+		// Bug 224: nothing the retired session left unfinished can run any more; close it so recovery never replays it.
+		if (this.store.mainTurn(convId)) this.completeTurn(convId, "interrupted");
+		rt.wake?.release?.();
+		rt.wake = null;
 		rt.sessionId = null;
 		rt.itemId = null;
 		rt.itemText = "";
@@ -1318,7 +1474,8 @@ export class Hub {
 		this.emit(convId, "conversation.thread", { threadId: to });
 		this.emit(convId, "session.rotated", { reason: retirement.reason, from: retirement.from, to });
 		this.emit(convId, "notice", { kind: "session-rotated", level: "info",
-			message: `새 엔진 세션으로 교체했습니다 (${this.reasonLabel(retirement.reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.` });
+			message: `새 엔진 세션으로 교체했습니다 (${this.reasonLabel(retirement.reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.${
+				retirement.reason === "compaction_failed" ? " 이전 세션 파일은 그대로 남겨 두었고, 받지 못한 메시지는 자동으로 다시 보내지 않습니다." : ""}` });
 	}
 
 	private closeTimer(callback: () => void, ms: number): ReturnType<typeof setTimeout> {
@@ -1595,6 +1752,7 @@ export class Hub {
 		const hours = Math.round((this.options.rotation?.maxAgeMs ?? ROTATE_MAX_AGE_MS) / 3_600_000);
 		if (reason === "size") return `세션 파일이 ${Math.round((this.options.rotation?.forceMaxBytes ?? FORCE_ROTATE_MAX_BYTES) / 1024 / 1024)}MB에 닿음`;
 		if (reason === "compactions") return `압축이 ${this.options.rotation?.forceUpdateCompactions ?? FORCE_ROTATE_UPDATE_COMPACTIONS}번 더 이어짐`;
+		if (reason === "compaction_failed") return `대화 요약이 ${this.freshSessionCompactionFailures()}번 연속 실패함`;
 		return reason === "manual" ? "직접 요청" : `세션이 ${hours}시간을 넘겨 쉬는 중`;
 	}
 
@@ -1617,7 +1775,7 @@ export class Hub {
 		}
 		return [
 			`[게이트웨이 알림] 이 대화는 새 엔진 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
-			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 필요한 부분만 검색해서 보세요.` : "",
+			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 끝부분이나 필요한 부분만 검색해서 보고, 전체를 읽지 마세요.` : "",
 			...this.handoffOpenItems(conv),
 			"아래는 직전 대화의 최근 부분입니다. 맥락으로만 참고하세요.",
 			"---",
@@ -1635,14 +1793,23 @@ export class Hub {
 		const rt = this.rt(convId);
 		if (rt.rotating) return; // Accepted user intent remains definitely unsent until rotation finishes.
 		const generation = this.generation;
+		let input: StoredEvent | null = null;
+		let nativeCommand = false;
+		let sessionId: string | null = null;
+		const releaseAdmission = () => {
+			if (rt.promptAdmissions.delete(releaseAdmission)) rt.admitting -= 1;
+		};
+		rt.promptAdmissions.add(releaseAdmission);
+		// Hold user admission through RPC settlement, including the idle-before-agent_start interval.
+		rt.admitting += 1;
 		try {
-			const { sessionId } = await this.ensureSession(conv);
+			({ sessionId } = await this.ensureSession(conv));
 			if (generation !== this.generation || this.omoStatus !== "ready") return;
 			const reference = messageSeq ?? this.store.lastSeq(convId, "message.user");
 			// sendText and reconnect recovery can share admission; only one may cross the write boundary.
 			if (admitted && this.store.mainUserDispatched(convId, reference)) return;
 			const commandName = body.slice(1).split(" ", 1)[0];
-			const nativeCommand = (body === "." && images.length === 0) ||
+			nativeCommand = (body === "." && images.length === 0) ||
 				(body.startsWith("/") && (await this.commands(convId)).some((command) => command.name === commandName));
 			if (generation !== this.generation || this.omoStatus !== "ready" || rt.sessionId !== sessionId) return;
 			if (admitted && this.store.mainUserDispatched(convId, reference)) return;
@@ -1660,7 +1827,7 @@ export class Hub {
 				...(rt.clientInputIdentity ? { clientInputId: inputId } : {}),
 			};
 			if (attached.images.length) params.images = attached.images;
-			const input = this.emit(convId, "main.input", {
+			input = this.emit(convId, "main.input", {
 				origin: "user", input_ref: { message_seq: reference },
 				session_path: this.store.getConversation(convId)?.threadId, handoff,
 				...(!nativeCommand || rt.clientInputIdentity ? {
@@ -1677,9 +1844,19 @@ export class Hub {
 			this.decisions?.refresh();
 		} catch (error) {
 			if (generation !== this.generation || this.omoStatus !== "ready") return;
+			// A retired session's late answer: retirement already closed its input, so it must not close or report it again.
+			const retired = sessionId !== null && rt.sessionId !== sessionId;
+			// Bug 224: the engine refused this prompt before accepting it, so it never runs and must not hold the turn.
+			// Native commands ("." continues through a queued custom message) and unknown delivery stay open.
+			const refused = !retired && input !== null && !nativeCommand && error instanceof OmoCommandError &&
+				error.command === "prompt" && error.code === REQUIRED_COMPACTION_REFUSAL && !this.store.mainInputConsumed(input);
+			if (refused && input) this.emit(convId, "main.input.handled", { input_seq: input.seq, reason: "prompt_rejected" });
 			if (protectedPayload) throw new SecurityRuntimeError("dispatch_unknown");
+			if (retired) return;
 			const message = errorMessage(error);
-			this.emit(convId, "error", this.continuityError(message));
+			this.emit(convId, "error", refused ? { kind: "compaction-required", message: COMPACTION_REQUIRED_MESSAGE } : this.continuityError(message));
+		} finally {
+			releaseAdmission();
 		}
 	}
 
@@ -1908,6 +2085,9 @@ export class Hub {
 						const recovery = COMPACTION_RECOVERY[outcome.failureKind];
 						this.emit(conv, "error", { kind: "compaction-failed", requestId, failureKind: outcome.failureKind,
 							action: recovery.action, message: `대화 요약에 실패했습니다. 이전 내용은 유지했습니다. ${recovery.message}` });
+						void this.logCompactionFailure(outcome.failureKind, event.failure)
+							.catch((error) => console.error(`compaction failure log: ${errorMessage(error)}`));
+						if (this.compactionFailuresInRow(conv) >= this.freshSessionCompactionFailures()) this.openFreshSession(conv);
 						break;
 					}
 					case "completed":
@@ -2577,7 +2757,7 @@ export class Hub {
 		if (!rt) {
 			rt = {
 				sessionId: null, opening: null, running: false, run: 0, rotating: false, admitting: 0, clientInputIdentity: false, atomicQueuedResume: false, durableId: null,
-				waking: null, wake: null, notified: new Set(),
+				waking: null, wake: null, notified: new Set(), promptAdmissions: new Set(),
 				itemId: null, itemText: "", statsTurnId: null, statsMessageIndex: 0,
 				rotationDone: null, finishRotation: null,
 			};

package/src/omo/client.ts

@@ -1,9 +1,20 @@
+import { FrameSocket } from "./frame-socket.ts";
 import { NativeLifecycleLog, type NativeLifecycleRecord } from "./lifecycle.ts";
 import { RecoveryReceiptLog } from "./recovery-receipt.ts";
 import type { RecoveryOpenContext, RecoveryReceiptRecord } from "./recovery-receipt-types.ts";
 
 export type OmoStatus = "connecting" | "ready" | "disconnected";
 
+interface OmoSocket {
+	readonly readyState: number;
+	onopen: (() => void) | null;
+	onmessage: ((event: { readonly data: string }) => void) | null;
+	onclose: ((event: { readonly code: number; readonly reason: string; readonly wasClean: boolean }) => void) | null;
+	onerror: ((event: { readonly message?: string }) => void) | null;
+	send(text: string): void;
+	close(): void;
+}
+
 export interface OmoEvent {
 	type: string;
 	sessionId?: string;
@@ -14,6 +25,8 @@ export interface OmoEvent {
 export const COMPACTION_FAILURE_KINDS = [
 	"invalid_model", "auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable",
 	"refused", "timeout", "incomplete", "empty", "context_budget", "stale", "provider",
+	// Bug 223: the provider's local account pool refused to send; quota versus auth is not known.
+	"account_blocked",
 ] as const;
 export type CompactionFailureKind = typeof COMPACTION_FAILURE_KINDS[number];
 export type CompactionOutcome =
@@ -79,7 +92,7 @@ type Pending = {
 const STABLE_READY_MS = 10_000;
 
 export class OmoClient {
-	private ws: WebSocket | null = null;
+	private ws: OmoSocket | null = null;
 	private nextId = 1;
 	private readonly instanceId = crypto.randomUUID();
 	private readonly pending = new Map<string, Pending>();
@@ -157,10 +170,12 @@ export class OmoClient {
 		this.setStatus("connecting");
 		this.recovery?.connecting();
 		if (this.stopped) return;
-		const ws = new WebSocket(this.url, { headers: {
+		const headers: Record<string, string> = {
 			Authorization: `Bearer ${this.token}`,
 			...(this.connectionId ? { "x-zgw-connection-id": this.connectionId } : {}),
-		} } as unknown as string[]);
+		};
+		const ws: OmoSocket = this.url.startsWith("ws://") ? new FrameSocket(this.url, headers)
+			: new WebSocket(this.url, { headers } as unknown as string[]) as unknown as OmoSocket;
 		this.ws = ws;
 		ws.onopen = () => {
 			let continuityLoss: string | undefined;