@happyvertical/ai 0.103.2 → 0.103.4

package/dist/chunks/{src-Cc5yFnnQ.js → src-BnMUshQt.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as createObservedAI, c as normalizeImageGenerationOptions, d as AI_PROVIDER_TYPES, f as AuthenticationError, g as ModelNotFoundError, l as prepareRequestControls, m as ContextLengthError, o as normalizeBaseAIOptions, p as ContentFilterError, s as normalizeChatOptions, t as emitUsage, u as AIError } from "./usage-B9gPCWSa.js";
-import { n as rateLimitErrorFrom, t as createRateLimitedAI } from "./rate-limit-BkK4-hXY.js";
-import { t as createContinuingAI } from "./continuation-L5KnnE9R.js";
+import { a as createObservedAI, c as normalizeImageGenerationOptions, d as AI_PROVIDER_TYPES, f as AuthenticationError, g as ModelNotFoundError, l as prepareRequestControls, m as ContextLengthError, o as normalizeBaseAIOptions, p as ContentFilterError, s as normalizeChatOptions, t as emitUsage, u as AIError } from "./usage-DS7uDhi1.js";
+import { n as rateLimitErrorFrom, t as createRateLimitedAI } from "./rate-limit-Dwyde1BY.js";
+import { t as createContinuingAI } from "./continuation-KdrnmvzP.js";
 import { ApiError, ValidationError, loadEnvConfig } from "@happyvertical/utils";
 import OpenAI from "openai";
 //#region src/shared/providers/openai.ts
@@ -1037,6 +1037,9 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 function isOpenAIOptions(options) {
 	return !options.type || options.type === "openai";
 }
+function isChatGPTPlanOptions(options) {
+	return options.type === "chatgpt-plan";
+}
 /**
 * Checks if the options are for LiteLLM provider
 * @param options - The AI provider options to check
@@ -1214,50 +1217,53 @@ async function getAI(options = {}) {
 	if (isOpenAIOptions(options)) {
 		const { OpenAIProvider } = await Promise.resolve().then(() => openai_exports);
 		client = new OpenAIProvider(options);
+	} else if (isChatGPTPlanOptions(options)) {
+		const { ChatGPTPlanProvider } = await Promise.resolve().then(() => chatgpt_plan_exports);
+		client = new ChatGPTPlanProvider(options);
 	} else if (isLiteLLMOptions(options)) {
-		const { LiteLLMProvider } = await import("./litellm-BaGgWzHR.js");
+		const { LiteLLMProvider } = await import("./litellm-8k7PMuh_.js");
 		client = new LiteLLMProvider(options);
 	} else if (isBifrostOptions(options)) {
-		const { BifrostProvider } = await import("./bifrost-DmbaXObX.js");
+		const { BifrostProvider } = await import("./bifrost-DZxTeE1Q.js");
 		client = new BifrostProvider(options);
 	} else if (isOllamaOptions(options)) {
-		const { OllamaProvider } = await import("./ollama-C3T3mn68.js");
+		const { OllamaProvider } = await import("./ollama-DHbYj2lH.js");
 		client = new OllamaProvider(options);
 	} else if (isGeminiOptions(options)) {
-		const { GeminiProvider } = await import("./gemini-C-r6c4N9.js");
+		const { GeminiProvider } = await import("./gemini-DCo6d-n1.js");
 		client = new GeminiProvider(options);
 	} else if (isAnthropicOptions(options)) {
-		const { AnthropicProvider } = await import("./anthropic-CdbK9Jl-.js");
+		const { AnthropicProvider } = await import("./anthropic-DhNGsQpl.js");
 		client = new AnthropicProvider(options);
 	} else if (isHuggingFaceOptions(options)) {
-		const { HuggingFaceProvider } = await import("./huggingface-DtuYF1vb.js");
+		const { HuggingFaceProvider } = await import("./huggingface-jqjeFPdr.js");
 		client = new HuggingFaceProvider(options);
 	} else if (isBedrockOptions(options)) {
-		const { BedrockProvider } = await import("./bedrock-DNkxz3ow.js");
+		const { BedrockProvider } = await import("./bedrock-CrtUO8yx.js");
 		client = new BedrockProvider(options);
 	} else if (isClaudeCliOptions(options)) {
-		const { ClaudeCliProvider } = await import("./claude-cli-C40pIzrp.js");
+		const { ClaudeCliProvider } = await import("./claude-cli-CW_gIocm.js");
 		client = new ClaudeCliProvider(options);
 	} else if (isQwen3TTSOptions(options)) {
-		const { Qwen3TTSProvider } = await import("./qwen-tts-DqMxfA54.js");
+		const { Qwen3TTSProvider } = await import("./qwen-tts-CWdO07D_.js");
 		client = new Qwen3TTSProvider(options);
 	} else if (isOpenAICompatVideoOptions(options)) {
-		const { OpenAICompatVideoProvider } = await import("./openai-compat-video-CwFsKAxR.js");
+		const { OpenAICompatVideoProvider } = await import("./openai-compat-video-ByTC2nzb.js");
 		client = new OpenAICompatVideoProvider(options);
 	} else if (isByteplusModelArkOptions(options)) {
-		const { ByteplusModelArkProvider } = await import("./byteplus-modelark-BAi0y9SK.js");
+		const { ByteplusModelArkProvider } = await import("./byteplus-modelark-gG941oea.js");
 		client = new ByteplusModelArkProvider(options);
 	} else if (isSeevioOptions(options)) {
-		const { SeevioProvider } = await import("./seevio-EzC6eKz-.js");
+		const { SeevioProvider } = await import("./seevio-B9V2nZtr.js");
 		client = new SeevioProvider(options);
 	} else if (isTypeSafeOptions(options)) {
-		const { TypeSafeProvider } = await import("./typesafe-D7ZmI9-n.js");
+		const { TypeSafeProvider } = await import("./typesafe-B1_jGusy.js");
 		client = new TypeSafeProvider(options);
 	} else if (isLayaOptions(options)) {
-		const { LayaProvider } = await import("./laya-D-P82D0h.js");
+		const { LayaProvider } = await import("./laya-D8o5TEO7.js");
 		client = new LayaProvider(options);
 	} else if (isWebLLMOptions(options)) {
-		const { WebLLMProvider } = await import("./webllm-DT31sqUY.js").then((n) => n.o);
+		const { WebLLMProvider } = await import("./webllm-DVDsgVT7.js").then((n) => n.o);
 		client = new WebLLMProvider(options);
 	} else throw new ValidationError("Unsupported AI provider type", {
 		supportedTypes: [...AI_PROVIDER_TYPES],
@@ -1383,6 +1389,442 @@ var AIMessage = class AIMessage {
 	}
 };
 //#endregion
+//#region src/shared/providers/chatgpt-plan.ts
+var chatgpt_plan_exports = /* @__PURE__ */ __exportAll({
+	ChatGPTPlanError: () => ChatGPTPlanError,
+	ChatGPTPlanProvider: () => ChatGPTPlanProvider,
+	ChatGPTPlanSessionRevokedError: () => ChatGPTPlanSessionRevokedError,
+	ChatGPTPlanUsageLimitError: () => ChatGPTPlanUsageLimitError,
+	ChatGPTPlanUsageUnavailableError: () => ChatGPTPlanUsageUnavailableError,
+	ChatGPTPlanWorkspaceError: () => ChatGPTPlanWorkspaceError
+});
+var PROVIDER = "chatgpt-plan";
+var MODELS_URL = "https://api.openai.com/v1/models";
+var RESPONSES_URL = "https://api.openai.com/v1/responses";
+/** Base error for the local ChatGPT plan-usage provider. */
+var ChatGPTPlanError = class extends AIError {
+	status;
+	requestId;
+	param;
+	constructor(message, code, status, requestId, param, retryable = false, model) {
+		super(message, code, PROVIDER, model, retryable);
+		this.status = status;
+		this.requestId = requestId;
+		this.param = param;
+		this.name = "ChatGPTPlanError";
+	}
+};
+/** The selected account or application limit stopped plan-usage inference. */
+var ChatGPTPlanUsageLimitError = class extends ChatGPTPlanError {
+	constructor(message, status, requestId, model) {
+		super(message, "subscription_sharing_usage_limit_exceeded", status, requestId, void 0, false, model);
+		this.name = "ChatGPTPlanUsageLimitError";
+	}
+};
+/** The selected user/workspace/policy does not allow this request. */
+var ChatGPTPlanWorkspaceError = class extends ChatGPTPlanError {
+	constructor(message, code, status, requestId, param, model) {
+		super(message, code, status, requestId, param, false, model);
+		this.name = "ChatGPTPlanWorkspaceError";
+	}
+};
+/** The saved registration can no longer authorize plan-usage requests. */
+var ChatGPTPlanSessionRevokedError = class extends ChatGPTPlanError {
+	constructor(message, code = "subscription_sharing_invalid_user", status, requestId, model) {
+		super(message, code, status, requestId, void 0, false, model);
+		this.name = "ChatGPTPlanSessionRevokedError";
+	}
+};
+/** Plan usage or account/workspace lookup is temporarily unavailable. */
+var ChatGPTPlanUsageUnavailableError = class extends ChatGPTPlanError {
+	constructor(message, code = "subscription_sharing_usage_unavailable", status, requestId, model) {
+		super(message, code, status, requestId, void 0, true, model);
+		this.name = "ChatGPTPlanUsageUnavailableError";
+	}
+};
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function safeTokenCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function mapUsage(value) {
+	if (!isRecord(value)) return void 0;
+	const promptTokens = safeTokenCount(value.input_tokens);
+	const completionTokens = safeTokenCount(value.output_tokens);
+	const totalTokens = safeTokenCount(value.total_tokens);
+	if (promptTokens === void 0 || completionTokens === void 0 || totalTokens === void 0) return void 0;
+	return {
+		promptTokens,
+		completionTokens,
+		totalTokens
+	};
+}
+function redact(value, token) {
+	return token ? value.split(token).join("[REDACTED]") : value;
+}
+function safeDiagnostic(value, token) {
+	return value === void 0 ? void 0 : redact(value, token);
+}
+function errorMessage(error) {
+	return typeof error?.message === "string" ? error.message : void 0;
+}
+function errorCode(error) {
+	return typeof error?.code === "string" ? error.code : void 0;
+}
+function errorParam(error) {
+	return typeof error?.param === "string" ? error.param : void 0;
+}
+function mappedError(input) {
+	const rawCode = errorCode(input.error);
+	const code = safeDiagnostic(rawCode, input.token);
+	const requestId = safeDiagnostic(input.requestId, input.token);
+	const diagnostic = redact(errorMessage(input.error) || input.detail || `ChatGPT plan request failed${input.status ? ` (${input.status})` : ""}`, input.token);
+	const param = safeDiagnostic(errorParam(input.error), input.token);
+	if (rawCode === "subscription_sharing_usage_limit_exceeded") return new ChatGPTPlanUsageLimitError(diagnostic, input.status, requestId, input.model);
+	if (rawCode === "subscription_sharing_usage_unavailable" || rawCode === "subscription_sharing_user_unavailable" || input.status === 503) return new ChatGPTPlanUsageUnavailableError(diagnostic, code || "subscription_sharing_usage_unavailable", input.status, requestId, input.model);
+	if (rawCode === "subscription_sharing_invalid_user" || input.status === 401) return new ChatGPTPlanSessionRevokedError(diagnostic, code || "subscription_sharing_invalid_user", input.status, requestId, input.model);
+	if (rawCode === "subscription_sharing_user_not_eligible" || rawCode === "subscription_sharing_route_not_supported" || rawCode === "chatpass_v2_scope_not_authorized" || rawCode === "chatpass_v2_invalid_authorization_context" || input.status === 403) return new ChatGPTPlanWorkspaceError(diagnostic, code || "workspace_restricted", input.status, requestId, param, input.model);
+	return new ChatGPTPlanError(diagnostic, code || "CHATGPT_PLAN_REQUEST_FAILED", input.status, requestId, param, Boolean(input.status && input.status >= 500), input.model);
+}
+async function responseError(response, token, model) {
+	const requestId = response.headers.get("x-request-id") || void 0;
+	const text = await response.text();
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch {
+		body = void 0;
+	}
+	const record = isRecord(body) ? body : void 0;
+	return mappedError({
+		error: isRecord(record?.error) ? record?.error : void 0,
+		detail: typeof record?.detail === "string" ? record.detail : text.slice(0, 500) || void 0,
+		status: response.status,
+		requestId,
+		token,
+		model
+	});
+}
+function frameData(frame) {
+	const values = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
+	return values.length ? values.join("\n") : void 0;
+}
+async function* sse(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			buffer += decoder.decode(value, { stream: !done });
+			const frames = buffer.split(/\r?\n\r?\n/);
+			buffer = frames.pop() || "";
+			for (const frame of frames) {
+				const data = frameData(frame);
+				if (data !== void 0) yield data;
+			}
+			if (done) break;
+		}
+		if (buffer.trim()) {
+			const data = frameData(buffer);
+			if (data !== void 0) yield data;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+function validateOptions(options) {
+	const present = [
+		"maxTokens",
+		"temperature",
+		"topP",
+		"n",
+		"stop",
+		"frequencyPenalty",
+		"presencePenalty",
+		"user",
+		"tools",
+		"toolChoice",
+		"responseFormat",
+		"responseSchema",
+		"seed",
+		"reasoning",
+		"thinkingLevel",
+		"includeThoughts"
+	].filter((key) => options[key] !== void 0);
+	if (present.length) throw new ChatGPTPlanError(`ChatGPT plan usage does not support request option(s): ${present.join(", ")}`, "subscription_sharing_unsupported_capability", 400, void 0, present[0]);
+}
+function inputFor(messages) {
+	if (!messages.length) throw new ChatGPTPlanError("ChatGPT plan usage requires at least one input message", "INVALID_REQUEST", 400);
+	return messages.map((message) => {
+		if (message.role === "function" || message.role === "tool" || message.tool_calls?.length || message.tool_call_id || message.name) throw new ChatGPTPlanError("ChatGPT plan usage does not support this tool/function message shape", "subscription_sharing_unsupported_capability", 400, void 0, "input");
+		return {
+			role: message.role === "system" ? "developer" : message.role,
+			content: typeof message.content === "string" ? message.content : message.content.map((part) => part.type === "text" ? {
+				type: "input_text",
+				text: part.text
+			} : {
+				type: "input_image",
+				image_url: part.image_url.url,
+				...part.image_url.detail ? { detail: part.image_url.detail } : {}
+			})
+		};
+	});
+}
+/**
+* Responses API adapter for an explicitly selected, locally authorized
+* ChatGPT plan. It uses only the public SIWC routes and never falls back to an
+* API-key provider.
+*/
+var ChatGPTPlanProvider = class {
+	options;
+	fetcher;
+	constructor(options) {
+		if (!options.clientId?.trim()) throw new ChatGPTPlanError("clientId is required for ChatGPT plan usage", "INVALID_CONFIGURATION");
+		if (typeof options.sessionManager?.accessToken !== "function") throw new ChatGPTPlanError("sessionManager.accessToken is required for ChatGPT plan usage", "INVALID_CONFIGURATION");
+		this.options = normalizeBaseAIOptions(options);
+		this.fetcher = options.fetch ?? fetch;
+	}
+	async token(model) {
+		try {
+			const token = await this.options.sessionManager.accessToken(this.options.clientId);
+			if (!token) throw new ChatGPTPlanSessionRevokedError("The selected ChatGPT session has no usable access token; sign in again", "session_invalidated", void 0, void 0, model);
+			return token;
+		} catch (error) {
+			if (error instanceof ChatGPTPlanError) throw error;
+			const code = isRecord(error) && typeof error.code === "string" ? error.code : void 0;
+			if (code && (/* @__PURE__ */ new Set([
+				"unknown_account",
+				"refresh_invalid",
+				"session_invalidated",
+				"plan_permission_missing"
+			])).has(code)) throw new ChatGPTPlanSessionRevokedError("The selected ChatGPT session is no longer authorized; sign in again", code, void 0, void 0, model);
+			throw new ChatGPTPlanUsageUnavailableError("The selected ChatGPT session is temporarily unavailable", "subscription_sharing_usage_unavailable", void 0, void 0, model);
+		}
+	}
+	async *events(messages, options) {
+		validateOptions(options);
+		const model = options.model || this.options.defaultModel;
+		if (!model) throw new ChatGPTPlanError("Select a model returned by getModels() before inference", "MODEL_REQUIRED");
+		const input = inputFor(messages);
+		const controls = prepareRequestControls(this.options, options);
+		let token = "";
+		try {
+			token = await this.token(model);
+			const response = await this.fetcher(RESPONSES_URL, {
+				method: "POST",
+				headers: {
+					...this.options.headers,
+					Authorization: `Bearer ${token}`,
+					"Content-Type": "application/json",
+					Accept: "text/event-stream"
+				},
+				body: JSON.stringify({
+					model,
+					input,
+					store: false,
+					stream: true
+				}),
+				signal: controls.signal
+			});
+			if (!response.ok) throw await responseError(response, token, model);
+			if (!response.body || !response.headers.get("content-type")?.toLowerCase().includes("text/event-stream")) throw new ChatGPTPlanError("ChatGPT plan response did not provide an event stream", "INVALID_RESPONSE", response.status, safeDiagnostic(response.headers.get("x-request-id") || void 0, token), void 0, false, model);
+			let completed = false;
+			for await (const data of sse(response.body)) {
+				if (data === "[DONE]") continue;
+				let event;
+				try {
+					event = JSON.parse(data);
+				} catch {
+					throw new ChatGPTPlanError("ChatGPT plan stream contained invalid JSON", "INVALID_RESPONSE", response.status, safeDiagnostic(response.headers.get("x-request-id") || void 0, token), void 0, false, model);
+				}
+				if (event.type === "response.output_text.delta" && typeof event.delta === "string") yield { delta: event.delta };
+				else if (event.type === "response.completed") {
+					completed = true;
+					yield { completed: {
+						model: typeof event.response?.model === "string" ? event.response.model : model,
+						usage: mapUsage(event.response?.usage)
+					} };
+				} else if (event.type === "response.failed") throw mappedError({
+					error: event.response?.error || event.error,
+					token,
+					status: response.status,
+					requestId: response.headers.get("x-request-id") || void 0,
+					model
+				});
+				else if (event.type === "error") throw mappedError({
+					error: event.error || event,
+					token,
+					status: response.status,
+					requestId: response.headers.get("x-request-id") || void 0,
+					model
+				});
+				else if (event.type === "response.incomplete") throw new ChatGPTPlanError("ChatGPT plan response was incomplete", "RESPONSE_INCOMPLETE", response.status, safeDiagnostic(response.headers.get("x-request-id") || void 0, token), "incomplete_details", false, model);
+			}
+			if (!completed) throw new ChatGPTPlanError("ChatGPT plan stream ended before response.completed", "STREAM_INTERRUPTED", response.status, safeDiagnostic(response.headers.get("x-request-id") || void 0, token), void 0, true, model);
+		} catch (error) {
+			if (controls.didTimeout()) throw new ChatGPTPlanError(`ChatGPT plan request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", void 0, void 0, void 0, true, model);
+			if (options.signal?.aborted) throw new ChatGPTPlanError("ChatGPT plan request was aborted", "AI_ABORTED", void 0, void 0, void 0, false, model);
+			if (error instanceof ChatGPTPlanError) throw error;
+			throw new ChatGPTPlanError(`Network error calling ChatGPT plan usage: ${redact(error instanceof Error ? error.message : String(error), token)}`, "NETWORK_ERROR", void 0, void 0, void 0, true, model);
+		} finally {
+			controls.cleanup();
+		}
+	}
+	async chat(messages, options = {}) {
+		const startedAt = Date.now();
+		let content = "";
+		let completed;
+		for await (const event of this.events(messages, options)) {
+			if (event.delta !== void 0) {
+				content += event.delta;
+				options.onProgress?.(event.delta);
+			}
+			if (event.completed) completed = event.completed;
+		}
+		options.onFinishReason?.("stop");
+		const model = completed?.model || options.model || this.options.defaultModel || "";
+		emitUsage(this.options, PROVIDER, "chat", model, completed?.usage, startedAt, options.usageTags);
+		return {
+			content,
+			model,
+			usage: completed?.usage,
+			finishReason: "stop"
+		};
+	}
+	async *stream(messages, options = {}) {
+		const startedAt = Date.now();
+		let completed;
+		for await (const event of this.events(messages, options)) {
+			if (event.delta !== void 0) {
+				options.onProgress?.(event.delta);
+				yield event.delta;
+			}
+			if (event.completed) completed = event.completed;
+		}
+		options.onFinishReason?.("stop");
+		emitUsage(this.options, PROVIDER, "stream", completed?.model || options.model || this.options.defaultModel || "", completed?.usage, startedAt, options.usageTags);
+	}
+	async complete(prompt, options = {}) {
+		return this.chat([{
+			role: "user",
+			content: prompt
+		}], options);
+	}
+	async message(text, options = {}) {
+		return (await this.chat([...options.history || [], {
+			role: options.role || "user",
+			content: text
+		}], options)).content;
+	}
+	async getModels() {
+		const controls = prepareRequestControls(this.options);
+		let token = "";
+		try {
+			token = await this.token();
+			const response = await this.fetcher(MODELS_URL, {
+				headers: {
+					...this.options.headers,
+					Authorization: `Bearer ${token}`,
+					Accept: "application/json"
+				},
+				signal: controls.signal
+			});
+			if (!response.ok) throw await responseError(response, token);
+			const body = await response.json();
+			if (!isRecord(body) || !Array.isArray(body.models)) throw new ChatGPTPlanError("ChatGPT plan model catalog omitted models", "INVALID_RESPONSE", response.status, safeDiagnostic(response.headers.get("x-request-id") || void 0, token));
+			return body.models.filter((entry) => isRecord(entry) && entry.visibility === "list" && typeof entry.slug === "string" && Boolean(entry.slug)).map((entry) => ({
+				id: entry.slug,
+				name: typeof entry.display_name === "string" ? entry.display_name : entry.slug,
+				contextLength: 0,
+				capabilities: ["text", "chat"],
+				supportsFunctions: false,
+				supportsVision: true
+			}));
+		} catch (error) {
+			if (controls.didTimeout()) throw new ChatGPTPlanUsageUnavailableError(`ChatGPT plan model discovery timed out after ${controls.timeout}ms`, "AI_TIMEOUT");
+			if (error instanceof ChatGPTPlanError) throw error;
+			throw new ChatGPTPlanError(`ChatGPT plan model discovery failed: ${redact(error instanceof Error ? error.message : String(error), token)}`, "NETWORK_ERROR", void 0, void 0, void 0, true);
+		} finally {
+			controls.cleanup();
+		}
+	}
+	async getCapabilities() {
+		return {
+			chat: true,
+			completion: true,
+			embeddings: false,
+			streaming: true,
+			functions: false,
+			vision: true,
+			fineTuning: false,
+			imageEmbeddings: false,
+			imageGeneration: false,
+			videoGeneration: false,
+			tts: false,
+			voiceCloning: false,
+			voiceDesign: false,
+			maxContextLength: 0,
+			supportedOperations: [
+				"chat",
+				"completion",
+				"streaming",
+				"vision"
+			]
+		};
+	}
+	async countTokens(text) {
+		return Math.ceil(text.length / 4);
+	}
+	unsupported() {
+		throw new ChatGPTPlanError("This operation is not supported by ChatGPT plan usage.", "NOT_IMPLEMENTED");
+	}
+	async embed(_text, _options) {
+		return this.unsupported();
+	}
+	async embedImage(_image, _options) {
+		return this.unsupported();
+	}
+	async describeImage(_image, _prompt, _options) {
+		return this.unsupported();
+	}
+	async generateImage(_prompt, _options) {
+		return this.unsupported();
+	}
+	async submitVideoGenerationJob(_options) {
+		return this.unsupported();
+	}
+	async getVideoGenerationJob(_handle) {
+		return this.unsupported();
+	}
+	async fetchVideoGenerationResult(_handle) {
+		return this.unsupported();
+	}
+	async cancelVideoGenerationJob(_handle) {
+		return this.unsupported();
+	}
+	async validateVideoGenerationAccess() {
+		return this.unsupported();
+	}
+	async synthesizeSpeech(_text, _options) {
+		return this.unsupported();
+	}
+	streamSpeech(_text, _options) {
+		const error = new ChatGPTPlanError("Speech streaming is not supported by ChatGPT plan usage.", "NOT_IMPLEMENTED");
+		return { [Symbol.asyncIterator]: () => ({ next: () => Promise.reject(error) }) };
+	}
+	async cloneVoice(_options) {
+		return this.unsupported();
+	}
+	async designVoice(_options) {
+		return this.unsupported();
+	}
+	async getVoices(_options) {
+		return this.unsupported();
+	}
+};
+//#endregion
 //#region src/shared/thread.ts
 /**
 * Represents a conversation thread with an AI model
@@ -1529,6 +1971,6 @@ var AIThread = class AIThread {
 /** @internal */
 var PACKAGE_VERSION_INITIALIZED = true;
 //#endregion
-export { getAI as a, OpenAIClient as c, OpenAIProvider as d, factory_exports as i, getAIClient as l, AIThread as n, getAIAuto as o, AIMessage as r, AIClient as s, PACKAGE_VERSION_INITIALIZED as t, getOpenAI as u };
+export { OpenAIProvider as _, ChatGPTPlanSessionRevokedError as a, ChatGPTPlanWorkspaceError as c, getAI as d, getAIAuto as f, getOpenAI as g, getAIClient as h, ChatGPTPlanProvider as i, AIMessage as l, OpenAIClient as m, AIThread as n, ChatGPTPlanUsageLimitError as o, AIClient as p, ChatGPTPlanError as r, ChatGPTPlanUsageUnavailableError as s, PACKAGE_VERSION_INITIALIZED as t, factory_exports as u };
 
-//# sourceMappingURL=src-Cc5yFnnQ.js.map
+//# sourceMappingURL=src-BnMUshQt.js.map