@agent-native/core 0.198.8 → 0.199.0-nightly-20261001034223

package/dist/agent/actions/disconnect-chatgpt-subscription.d.ts

@@ -1,4 +1,13 @@
-declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, {
+declare const _default: import("../../action.js").ActionDefinition<{
+    accountId?: string;
+    removeLegacyCredential?: boolean;
+}, {
+    removed: boolean;
+    remoteRevocationConfirmed: false;
+} | {
+    disconnectedAccountId: string | null;
+    activeAccountId: string | null;
     connected: boolean;
+    remoteRevocationConfirmed: boolean;
 }>;
 export default _default;

package/dist/agent/actions/disconnect-chatgpt-subscription.js

@@ -1,14 +1,32 @@
 import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
-import { disconnectChatGPTSubscription } from "../../server/chatgpt-subscription-oauth.js";
+import { disconnectChatGPTSubscription, removeLegacyChatGPTSubscriptionCredential, } from "../../server/chatgpt-subscription-oauth.js";
 export default defineAction({
-    description: "Disconnect the current user's ChatGPT subscription from the experimental Codex engine.",
-    schema: z.object({}),
+    description: "Sign out of one of the current user's saved ChatGPT registrations, or remove an unusable credential from the older experimental ChatGPT flow. Remote revocation is attempted for current registrations; it cannot be confirmed for the older credential.",
+    schema: z.object({
+        accountId: z
+            .string()
+            .optional()
+            .describe("Saved ChatGPT registration ID. Omit to disconnect the active registration."),
+        removeLegacyCredential: z
+            .boolean()
+            .optional()
+            .describe("Remove the user's unusable credential from the older experimental ChatGPT flow."),
+    }),
     run: async (_args, ctx) => {
         const email = ctx?.userEmail;
         if (!email)
             fail("Not authenticated.", { statusCode: 401 });
-        await disconnectChatGPTSubscription(email);
-        return { connected: false };
+        try {
+            if (_args.removeLegacyCredential) {
+                return await removeLegacyChatGPTSubscriptionCredential(email);
+            }
+            return await disconnectChatGPTSubscription(email, _args.accountId);
+        }
+        catch (error) {
+            fail(error instanceof Error
+                ? error.message
+                : "Unable to disconnect ChatGPT.", { statusCode: 400 });
+        }
     },
 });

package/dist/agent/actions/get-chatgpt-subscription-status.d.ts

@@ -1,7 +1,2 @@
-declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, {
-    labEnabled: boolean;
-    connected: boolean;
-    reconnectRequired: boolean;
-    accountId: string | null;
-}>;
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, import("../../server/chatgpt-subscription-oauth.js").ChatGPTSubscriptionStatus>;
 export default _default;

package/dist/agent/actions/get-chatgpt-subscription-status.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
 import { getChatGPTSubscriptionStatus } from "../../server/chatgpt-subscription-oauth.js";
 export default defineAction({
-    description: "Return the current user's experimental ChatGPT subscription connection status.",
+    description: "Return the current user's ChatGPT subscription support, selected registration, and saved account registrations.",
     schema: z.object({}),
     http: { method: "GET" },
     run: async (_args, ctx) => {

package/dist/agent/actions/list-chatgpt-subscription-accounts.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, {
+    accounts: import("../../server/chatgpt-subscription-oauth.js").ChatGPTSubscriptionAccountSummary[];
+    activeAccountId: string | null;
+}>;
+export default _default;

package/dist/agent/actions/list-chatgpt-subscription-accounts.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { defineAction, fail } from "../../action.js";
+import { listChatGPTSubscriptionAccounts } from "../../server/chatgpt-subscription-oauth.js";
+export default defineAction({
+    description: "List the current user's saved ChatGPT registrations without exposing credentials.",
+    schema: z.object({}),
+    http: { method: "GET" },
+    run: async (_args, ctx) => {
+        const email = ctx?.userEmail;
+        if (!email)
+            fail("Not authenticated.", { statusCode: 401 });
+        return listChatGPTSubscriptionAccounts(email);
+    },
+});

package/dist/agent/actions/select-chatgpt-subscription-account.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    accountId: string;
+}, {
+    activeAccountId: string;
+    connected: boolean;
+}>;
+export default _default;

package/dist/agent/actions/select-chatgpt-subscription-account.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { defineAction, fail } from "../../action.js";
+import { selectChatGPTSubscriptionAccount } from "../../server/chatgpt-subscription-oauth.js";
+export default defineAction({
+    description: "Set one of the current user's saved ChatGPT registrations as active.",
+    schema: z.object({
+        accountId: z.string().min(1).max(80),
+    }),
+    run: async (args, ctx) => {
+        const email = ctx?.userEmail;
+        if (!email)
+            fail("Not authenticated.", { statusCode: 401 });
+        try {
+            return await selectChatGPTSubscriptionAccount(email, args.accountId);
+        }
+        catch (error) {
+            fail(error instanceof Error
+                ? error.message
+                : "Unable to select ChatGPT account.", { statusCode: 400 });
+        }
+    },
+});

package/dist/agent/chatgpt-subscription-contract.d.ts

@@ -1,5 +1,15 @@
-export declare const CHATGPT_SUBSCRIPTION_LAB_KEY = "agent.chatgpt-subscription";
 export declare const CHATGPT_SUBSCRIPTION_ENGINE_NAME = "chatgpt-subscription";
-export declare const CHATGPT_SUBSCRIPTION_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-export declare const CHATGPT_SUBSCRIPTION_MODELS: readonly ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"];
-export declare const CHATGPT_SUBSCRIPTION_DEFAULT_MODEL: "gpt-5.5";
+export declare const CHATGPT_SUBSCRIPTION_RESOURCE = "https://api.openai.com/v1";
+export declare const CHATGPT_SUBSCRIPTION_ENDPOINT = "https://api.openai.com/v1/responses";
+export declare const CHATGPT_SUBSCRIPTION_AUTHORIZATION_ENDPOINT = "https://auth.openai.com/api/accounts/authorize";
+export declare const CHATGPT_SUBSCRIPTION_TOKEN_ENDPOINT = "https://auth.openai.com/api/accounts/oauth/token";
+export declare const CHATGPT_SUBSCRIPTION_ISSUER = "https://auth.openai.com";
+export declare const CHATGPT_SUBSCRIPTION_JWKS_URI = "https://auth.openai.com/.well-known/jwks.json";
+export declare const CHATGPT_SUBSCRIPTION_OIDC_CONFIGURATION_URI = "https://auth.openai.com/.well-known/openid-configuration";
+export declare const CHATGPT_SUBSCRIPTION_DYNAMIC_CLIENT_ID = "dynamic_agent_client";
+export declare const CHATGPT_SUBSCRIPTION_CALLBACK_PATH = "/auth/callback";
+export declare const CHATGPT_SUBSCRIPTION_HOST_ID_SETTING_KEY = "agent.chatgpt-subscription.host-id";
+export declare const CHATGPT_SUBSCRIPTION_ACTIVE_ACCOUNT_SETTING_KEY = "agent.chatgpt-subscription.active-account";
+export declare const CHATGPT_SUBSCRIPTION_REGISTRATIONS_SETTING_KEY = "agent.chatgpt-subscription.registrations";
+export declare const CHATGPT_SUBSCRIPTION_PROVIDER = "openai-codex";
+export declare const CHATGPT_SUBSCRIPTION_SCOPES: readonly ["openid", "profile", "email", "offline_access", "resource.invoke", "chatgpt.tokens.use.direct"];

package/dist/agent/chatgpt-subscription-contract.js

@@ -1,10 +1,22 @@
-export const CHATGPT_SUBSCRIPTION_LAB_KEY = "agent.chatgpt-subscription";
 export const CHATGPT_SUBSCRIPTION_ENGINE_NAME = "chatgpt-subscription";
-export const CHATGPT_SUBSCRIPTION_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-export const CHATGPT_SUBSCRIPTION_MODELS = [
-    "gpt-5.5",
-    "gpt-5.4",
-    "gpt-5.4-mini",
-    "gpt-5.3-codex-spark",
+export const CHATGPT_SUBSCRIPTION_RESOURCE = "https://api.openai.com/v1";
+export const CHATGPT_SUBSCRIPTION_ENDPOINT = `${CHATGPT_SUBSCRIPTION_RESOURCE}/responses`;
+export const CHATGPT_SUBSCRIPTION_AUTHORIZATION_ENDPOINT = "https://auth.openai.com/api/accounts/authorize";
+export const CHATGPT_SUBSCRIPTION_TOKEN_ENDPOINT = "https://auth.openai.com/api/accounts/oauth/token";
+export const CHATGPT_SUBSCRIPTION_ISSUER = "https://auth.openai.com";
+export const CHATGPT_SUBSCRIPTION_JWKS_URI = "https://auth.openai.com/.well-known/jwks.json";
+export const CHATGPT_SUBSCRIPTION_OIDC_CONFIGURATION_URI = "https://auth.openai.com/.well-known/openid-configuration";
+export const CHATGPT_SUBSCRIPTION_DYNAMIC_CLIENT_ID = "dynamic_agent_client";
+export const CHATGPT_SUBSCRIPTION_CALLBACK_PATH = "/auth/callback";
+export const CHATGPT_SUBSCRIPTION_HOST_ID_SETTING_KEY = "agent.chatgpt-subscription.host-id";
+export const CHATGPT_SUBSCRIPTION_ACTIVE_ACCOUNT_SETTING_KEY = "agent.chatgpt-subscription.active-account";
+export const CHATGPT_SUBSCRIPTION_REGISTRATIONS_SETTING_KEY = "agent.chatgpt-subscription.registrations";
+export const CHATGPT_SUBSCRIPTION_PROVIDER = "openai-codex";
+export const CHATGPT_SUBSCRIPTION_SCOPES = [
+    "openid",
+    "profile",
+    "email",
+    "offline_access",
+    "resource.invoke",
+    "chatgpt.tokens.use.direct",
 ];
-export const CHATGPT_SUBSCRIPTION_DEFAULT_MODEL = CHATGPT_SUBSCRIPTION_MODELS[0];

package/dist/agent/engine/builtin.js

@@ -1,5 +1,5 @@
 import { AppConfigurationError, getAppConfig } from "../../app-config/index.js";
-import { CHATGPT_SUBSCRIPTION_DEFAULT_MODEL, CHATGPT_SUBSCRIPTION_ENGINE_NAME, CHATGPT_SUBSCRIPTION_MODELS, } from "../chatgpt-subscription-contract.js";
+import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../chatgpt-subscription-contract.js";
 import { createAISDKEngine, PROVIDER_CAPABILITIES, PROVIDER_DEFAULT_MODELS, PROVIDER_SUPPORTED_MODELS, PROVIDER_ENV_VARS, PROVIDER_PACKAGES, } from "./ai-sdk-engine.js";
 import { createAnthropicEngine, ANTHROPIC_CAPABILITIES, ANTHROPIC_DEFAULT_MODEL, ANTHROPIC_SUPPORTED_MODELS, } from "./anthropic-engine.js";
 import { createBuilderEngine, BUILDER_CAPABILITIES, BUILDER_DEFAULT_MODEL, BUILDER_SUPPORTED_MODELS, } from "./builder-engine.js";
@@ -78,11 +78,11 @@ function builtinEngineEntries() {
         })),
         {
             name: CHATGPT_SUBSCRIPTION_ENGINE_NAME,
-            label: "ChatGPT subscription",
-            description: "Experimental Codex access through a user's ChatGPT subscription. Enable the matching lab first.",
+            label: "ChatGPT plan access",
+            description: "Use eligible OpenAI models through a user's ChatGPT plan.",
             capabilities: PROVIDER_CAPABILITIES.openai,
-            defaultModel: CHATGPT_SUBSCRIPTION_DEFAULT_MODEL,
-            supportedModels: CHATGPT_SUBSCRIPTION_MODELS,
+            defaultModel: "",
+            supportedModels: [],
             acceptsCustomModels: false,
             requiredEnvVars: [],
             create: (config) => createChatGPTSubscriptionEngine(config),

package/dist/agent/engine/chatgpt-subscription-engine.d.ts

@@ -1,3 +1,9 @@
 import type { AgentEngine } from "./types.js";
+export declare function normalizeChatGPTSubscriptionResponsesBody(body: unknown): string;
+export interface ChatGPTSubscriptionModelCatalog {
+    models: string[];
+    modelDisplayNames: Record<string, string>;
+}
+export declare function listChatGPTSubscriptionModels(email: string): Promise<ChatGPTSubscriptionModelCatalog>;
 export declare function createChatGPTSubscriptionFetch(email: string): typeof fetch;
 export declare function createChatGPTSubscriptionEngine(config?: Record<string, unknown>): AgentEngine;

package/dist/agent/engine/chatgpt-subscription-engine.js

@@ -1,37 +1,68 @@
 import { getChatGPTSubscriptionAccess, markChatGPTSubscriptionReconnectRequired, } from "../../server/chatgpt-subscription-oauth.js";
 import { getRequestUserEmail } from "../../server/request-context.js";
-import { CHATGPT_SUBSCRIPTION_DEFAULT_MODEL, CHATGPT_SUBSCRIPTION_ENDPOINT, CHATGPT_SUBSCRIPTION_ENGINE_NAME, CHATGPT_SUBSCRIPTION_MODELS, } from "../chatgpt-subscription-contract.js";
+import { CHATGPT_SUBSCRIPTION_ENDPOINT, CHATGPT_SUBSCRIPTION_ENGINE_NAME, } from "../chatgpt-subscription-contract.js";
 import { createAISDKEngine, PROVIDER_CAPABILITIES } from "./ai-sdk-engine.js";
 const OPENAI_RESPONSES_BASE_URL = "https://api.openai.com/v1";
+const UNSUPPORTED_RESPONSES_FIELDS = [
+    "background",
+    "conversation",
+    "max_output_tokens",
+    "max_tool_calls",
+    "metadata",
+    "moderation",
+    "multi_agent",
+    "previous_response_id",
+    "prompt",
+    "prompt_cache_retention",
+    "safety_identifier",
+    "temperature",
+    "top_logprobs",
+    "top_p",
+    "truncation",
+    "user",
+];
 function requestUrl(input) {
     return input instanceof URL
         ? input
         : new URL(typeof input === "string" ? input : input.url);
 }
-function copyHeaders(input, init) {
+function requestHeaders(input, init) {
     const headers = new Headers(input instanceof Request ? input.headers : undefined);
     if (init?.headers) {
         new Headers(init.headers).forEach((value, key) => headers.set(key, value));
     }
     headers.delete("authorization");
-    headers.delete("Authorization");
+    headers.delete("originator");
+    headers.delete("chatgpt-account-id");
     return headers;
 }
-function stripUnsupportedRequestFields(body) {
-    if (typeof body !== "string")
-        return body;
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function normalizeChatGPTSubscriptionResponsesBody(body) {
+    if (typeof body !== "string") {
+        throw new Error("Sign in with ChatGPT requires a JSON Responses request.");
+    }
+    let value;
     try {
-        const parsed = JSON.parse(body);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            return body;
-        }
-        const request = { ...parsed };
-        delete request.max_output_tokens;
-        return JSON.stringify(request);
+        value = JSON.parse(body);
     }
     catch {
-        return body;
+        throw new Error("Sign in with ChatGPT received invalid Responses JSON.");
+    }
+    if (!isRecord(value) || !Array.isArray(value.input)) {
+        throw new Error("Sign in with ChatGPT requires Responses input as an array.");
     }
+    const request = { ...value };
+    for (const field of UNSUPPORTED_RESPONSES_FIELDS)
+        delete request[field];
+    const input = request.input;
+    request.input = input.map((item) => isRecord(item) && item.role === "system"
+        ? { ...item, role: "developer" }
+        : item);
+    request.store = false;
+    request.stream = true;
+    return JSON.stringify(request);
 }
 function currentUserEmail(config) {
     const configured = typeof config.userEmail === "string" ? config.userEmail.trim() : "";
@@ -39,56 +70,125 @@ function currentUserEmail(config) {
         return configured;
     return getRequestUserEmail()?.trim() ?? "";
 }
+async function markUnauthorized(email, response) {
+    if (response.status === 401) {
+        await markChatGPTSubscriptionReconnectRequired(email);
+    }
+}
+async function readChatGPTSubscriptionModelCatalog(accessToken, email) {
+    const response = await fetch(`${OPENAI_RESPONSES_BASE_URL}/models`, {
+        method: "GET",
+        headers: { authorization: `Bearer ${accessToken}` },
+        cache: "no-store",
+        redirect: "error",
+    });
+    await markUnauthorized(email, response);
+    if (!response.ok) {
+        throw new Error(`OpenAI ChatGPT model listing failed with HTTP ${response.status}.`);
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        throw new Error("OpenAI returned invalid ChatGPT model-list JSON.");
+    }
+    if (!isRecord(payload) || !Array.isArray(payload.models)) {
+        throw new Error("OpenAI returned an invalid ChatGPT model catalog.");
+    }
+    const models = [];
+    const modelDisplayNameEntries = [];
+    const seen = new Set();
+    for (const item of payload.models) {
+        if (!isRecord(item)) {
+            throw new Error("OpenAI returned an invalid ChatGPT model-list row.");
+        }
+        if (item.visibility !== "list")
+            continue;
+        const { slug, display_name: displayName } = item;
+        if (typeof slug !== "string" ||
+            !slug.trim() ||
+            slug.length > 200 ||
+            /[\s\p{Cc}]/u.test(slug) ||
+            typeof displayName !== "string" ||
+            !displayName.trim() ||
+            displayName.length > 200 ||
+            /[\p{Cc}]/u.test(displayName)) {
+            throw new Error("OpenAI returned an invalid visible ChatGPT model.");
+        }
+        if (seen.has(slug)) {
+            throw new Error("OpenAI returned a duplicate visible ChatGPT model.");
+        }
+        seen.add(slug);
+        models.push(slug);
+        modelDisplayNameEntries.push([slug, displayName]);
+    }
+    if (models.length === 0) {
+        throw new Error("The selected ChatGPT account has no visible models.");
+    }
+    return {
+        models,
+        modelDisplayNames: Object.fromEntries(modelDisplayNameEntries),
+    };
+}
+export async function listChatGPTSubscriptionModels(email) {
+    const access = await getChatGPTSubscriptionAccess(email);
+    return readChatGPTSubscriptionModelCatalog(access.accessToken, email);
+}
 export function createChatGPTSubscriptionFetch(email) {
     return async (input, init) => {
+        const target = requestUrl(input);
+        const endpoint = new URL(CHATGPT_SUBSCRIPTION_ENDPOINT);
+        if (target.origin !== endpoint.origin ||
+            target.pathname !== endpoint.pathname ||
+            target.search ||
+            target.hash) {
+            throw new Error("Sign in with ChatGPT requests must use the public OpenAI Responses API.");
+        }
+        const source = input instanceof Request ? input : undefined;
+        const method = init?.method ?? source?.method ?? "GET";
+        if (method.toUpperCase() !== "POST") {
+            throw new Error("The OpenAI Responses API requires POST requests.");
+        }
+        const body = source && init?.body === undefined
+            ? await source.clone().text()
+            : init?.body;
         const access = await getChatGPTSubscriptionAccess(email);
-        const parsed = requestUrl(input);
-        const rewrite = parsed.pathname.includes("/v1/responses") ||
-            parsed.pathname.includes("/chat/completions");
-        const url = rewrite ? new URL(CHATGPT_SUBSCRIPTION_ENDPOINT) : parsed;
-        const headers = copyHeaders(input, init);
+        const headers = requestHeaders(input, init);
         headers.set("authorization", `Bearer ${access.accessToken}`);
-        headers.set("originator", "agent-native");
-        headers.set("user-agent", "agent-native-framework");
-        if (access.accountId)
-            headers.set("ChatGPT-Account-Id", access.accountId);
-        const source = input instanceof Request ? input : undefined;
-        const requestInit = {
-            ...(source
-                ? {
-                    method: source.method,
-                    body: source.method === "GET" || source.method === "HEAD"
-                        ? undefined
-                        : source.body,
-                    signal: source.signal,
-                }
-                : {}),
+        headers.set("content-type", "application/json");
+        const requestBody = JSON.parse(normalizeChatGPTSubscriptionResponsesBody(body));
+        if (typeof requestBody.model !== "string" || !requestBody.model.trim()) {
+            const catalog = await readChatGPTSubscriptionModelCatalog(access.accessToken, email);
+            const model = catalog.models[0];
+            if (!model) {
+                throw new Error("The selected ChatGPT account has no visible models.");
+            }
+            requestBody.model = model;
+        }
+        const response = await fetch(endpoint, {
             ...(init ?? {}),
+            method: "POST",
             headers,
-        };
-        if (rewrite) {
-            requestInit.body =
-                source && init?.body === undefined
-                    ? stripUnsupportedRequestFields(await source.clone().text())
-                    : stripUnsupportedRequestFields(requestInit.body);
-        }
-        const response = await fetch(url, requestInit);
-        if (response.status === 401) {
-            await markChatGPTSubscriptionReconnectRequired(email).catch(() => { });
-        }
+            body: JSON.stringify(requestBody),
+            cache: "no-store",
+            redirect: "error",
+            ...(source?.signal ? { signal: source.signal } : {}),
+        });
+        await markUnauthorized(email, response);
         return response;
     };
 }
 export function createChatGPTSubscriptionEngine(config = {}) {
     const email = currentUserEmail(config);
     if (!email) {
-        throw new Error("A signed-in user is required for a ChatGPT subscription.");
+        throw new Error("A signed-in user is required for ChatGPT plan access.");
     }
     return createAISDKEngine("openai", {
         name: CHATGPT_SUBSCRIPTION_ENGINE_NAME,
-        label: "ChatGPT subscription",
-        model: CHATGPT_SUBSCRIPTION_DEFAULT_MODEL,
-        supportedModels: CHATGPT_SUBSCRIPTION_MODELS,
+        label: "ChatGPT plan access",
+        model: typeof config.model === "string" ? config.model : "",
+        supportedModels: [],
         acceptsCustomModels: false,
         capabilities: PROVIDER_CAPABILITIES.openai,
         apiKey: "chatgpt-subscription",

package/dist/agent/engine/registry.js

@@ -2,14 +2,13 @@ import { createRequire } from "node:module";
 import { getAppConfig } from "../../app-config/index.js";
 import { assertCredentialCanReachEndpoint, } from "../../credentials/index.js";
 import { isBlockedExtensionUrlWithDns } from "../../extensions/url-safety.js";
-import { getUserLabs } from "../../labs/store.js";
 import { BUILDER_OAUTH_SCOPE, hasBuilderOAuthSession, resolveBuilderOAuthRequestAccess, } from "../../server/builder-oauth.js";
 import { hasChatGPTSubscriptionCredential } from "../../server/chatgpt-subscription-oauth.js";
 import { assertCredentialStoreReadable, canUseDeployCredentialFallbackForRequest, getBuilderCredentialAuthFailure, getProviderCredentialAuthFailure, isTrustedSelfHostedRuntime, prefetchSecrets, readDeployCredentialEnv, resolveBuilderCredentialsDetailed, resolveBuilderGatewayCredentialsDetailed, resolveSecretDetailed, } from "../../server/credential-provider.js";
 import { getRequestOrgId, getRequestContext, getRequestUserEmail, } from "../../server/request-context.js";
 import { resolveSecretWithAliasesDetailed, secretKeyNames, } from "../../server/secret-key-aliases.js";
 import { getAgentAppModelDefaultForCurrentRequest } from "../app-model-defaults.js";
-import { CHATGPT_SUBSCRIPTION_ENGINE_NAME, CHATGPT_SUBSCRIPTION_LAB_KEY, } from "../chatgpt-subscription-contract.js";
+import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../chatgpt-subscription-contract.js";
 import { readDefaultAgentEngineSetting } from "../default-agent-engine.js";
 import { createProviderEndpointFetch } from "./ai-sdk-engine.js";
 import { OLLAMA_DEFAULT_BASE_URL, OLLAMA_BASE_URL_ENV_VAR, OPENAI_BASE_URL_ENV_VAR, isCustomOpenAiBaseUrl, } from "./openai-compatible-endpoint.js";
@@ -597,9 +596,6 @@ async function chatGPTSubscriptionUsableForRequest(identity) {
     const email = identityUserEmail(identity);
     if (!email)
         return false;
-    const labs = await getUserLabs(email);
-    if (labs[CHATGPT_SUBSCRIPTION_LAB_KEY] !== true)
-        return false;
     return hasChatGPTSubscriptionCredential(email);
 }
 /**
@@ -643,7 +639,7 @@ async function engineCreateConfigForEntry(entry, apiKey, extra, credentialResolu
         const email = identityUserEmail(credentialIdentity);
         if (!email ||
             !(await chatGPTSubscriptionUsableForRequest(credentialIdentity))) {
-            throw new Error("Enable the ChatGPT subscription lab and connect a ChatGPT subscription before using this engine.");
+            throw new Error("Connect a ChatGPT account with direct model access before using this engine.");
         }
         safeExtra.userEmail = email;
     }

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

package/dist/client/chat-model-groups.d.ts

@@ -2,12 +2,15 @@ export interface EngineModelGroup {
     engine: string;
     label: string;
     models: string[];
+    modelDisplayNames?: Readonly<Record<string, string>>;
     configured: boolean;
+    isSubscription?: boolean;
 }
 export interface ChatModelEngineEntry {
     name: string;
     label: string;
     supportedModels?: readonly string[];
+    modelDisplayNames?: Readonly<Record<string, string>>;
     acceptsCustomModels?: boolean;
     preserveCustomModels?: boolean;
     requiredEnvVars?: readonly string[];

package/dist/client/chat-model-groups.js

@@ -1,3 +1,4 @@
+import { CHATGPT_SUBSCRIPTION_ENGINE_NAME } from "../agent/chatgpt-subscription-contract.js";
 export function modelCatalogConfirmsMissing(groups, loading) {
     return (loading === false &&
         groups !== undefined &&
@@ -116,6 +117,8 @@ function shouldShowDirectEngine(engine, configured, currentEngineName) {
         return false;
     if (engine.name === "ai-sdk:anthropic")
         return false;
+    if (engine.name === CHATGPT_SUBSCRIPTION_ENGINE_NAME)
+        return configured;
     // Keyless engines (Ollama) always report ready, so only models someone
     // checked for them say they are set up.
     if (engine.requiredEnvVars?.length === 0) {
@@ -159,10 +162,18 @@ export function buildChatModelGroups({ engines, configuredKeys, builderConnected
         const group = {
             engine: engine.name,
             label: engine.label,
-            models: sortModelsByCost(modelsFor(engine, true)),
+            models: engine.name === CHATGPT_SUBSCRIPTION_ENGINE_NAME
+                ? modelsFor(engine, false)
+                : sortModelsByCost(modelsFor(engine, true)),
+            ...(engine.modelDisplayNames
+                ? { modelDisplayNames: engine.modelDisplayNames }
+                : {}),
             configured: engine.configured ??
                 (requiredEnvVars.length === 0 ||
                     requiredEnvVars.some((key) => configured.has(key))),
+            ...(engine.name === CHATGPT_SUBSCRIPTION_ENGINE_NAME
+                ? { isSubscription: true }
+                : {}),
         };
         return { engine, group };
     })

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -8,16 +8,16 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     state: string;
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;
 }>>;
 export declare const postCollabText: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     ok?: undefined;
-    error: string;
     text?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -33,9 +33,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     idempotencyKey: string;
     deleted: boolean;
 } | {
+    id?: undefined;
     error: string;
     url?: undefined;
-    id?: undefined;
     provider?: undefined;
     configured?: undefined;
 } | {
@@ -45,8 +45,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     configured?: undefined;
     error?: undefined;
 } | {
-    url?: undefined;
     id?: undefined;
+    url?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;

package/dist/framework-tools.js

@@ -112,6 +112,8 @@ export const CORE_ACTION_GROUPS = {
     "set-lab": "labs",
     "get-chatgpt-subscription-status": "chat",
     "disconnect-chatgpt-subscription": "chat",
+    "list-chatgpt-subscription-accounts": "chat",
+    "select-chatgpt-subscription-account": "chat",
     "preview-secret-removal": "chat",
     "list-api-keys": "chat",
     "delete-api-key": "chat",