oc-chatgpt-multi-auth 5.3.4 → 5.4.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA+J/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MA8kK/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA+J/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MA8yK/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}

package/dist/index.js

@@ -350,6 +350,93 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     cooldownReason: mergedCooldownReason,
                 };
             };
+            const normalizeStoredAccountId = (account) => {
+                const accountId = account?.accountId?.trim();
+                return accountId && accountId.length > 0 ? accountId : undefined;
+            };
+            const hasDistinctNonEmptyAccountIds = (left, right) => {
+                const leftId = normalizeStoredAccountId(left);
+                const rightId = normalizeStoredAccountId(right);
+                return !!leftId && !!rightId && leftId !== rightId;
+            };
+            const canCollapseWithCandidateAccountId = (existing, candidateAccountId) => {
+                const existingAccountId = normalizeStoredAccountId(existing);
+                const normalizedCandidate = candidateAccountId?.trim() || undefined;
+                if (!existingAccountId || !normalizedCandidate) {
+                    return true;
+                }
+                return existingAccountId === normalizedCandidate;
+            };
+            const resolveOrganizationMatch = (indexes, organizationId, candidateAccountId) => {
+                const matches = indexes.byOrganizationId.get(organizationId);
+                if (!matches || matches.length === 0)
+                    return undefined;
+                const candidateId = candidateAccountId?.trim() || undefined;
+                let newestNoAccountId;
+                let newestExactAccountId;
+                let newestAnyNonEmptyAccountId;
+                const distinctNonEmptyAccountIds = new Set();
+                for (const index of matches) {
+                    const existing = accounts[index];
+                    if (!existing)
+                        continue;
+                    const existingAccountId = normalizeStoredAccountId(existing);
+                    if (!existingAccountId) {
+                        newestNoAccountId =
+                            typeof newestNoAccountId === "number"
+                                ? pickNewestAccountIndex(newestNoAccountId, index)
+                                : index;
+                        continue;
+                    }
+                    distinctNonEmptyAccountIds.add(existingAccountId);
+                    newestAnyNonEmptyAccountId =
+                        typeof newestAnyNonEmptyAccountId === "number"
+                            ? pickNewestAccountIndex(newestAnyNonEmptyAccountId, index)
+                            : index;
+                    if (candidateId && existingAccountId === candidateId) {
+                        newestExactAccountId =
+                            typeof newestExactAccountId === "number"
+                                ? pickNewestAccountIndex(newestExactAccountId, index)
+                                : index;
+                    }
+                }
+                if (candidateId) {
+                    return newestExactAccountId ?? newestNoAccountId;
+                }
+                if (typeof newestNoAccountId === "number") {
+                    return newestNoAccountId;
+                }
+                if (distinctNonEmptyAccountIds.size === 1) {
+                    return newestAnyNonEmptyAccountId;
+                }
+                return undefined;
+            };
+            const resolveNoOrgRefreshMatch = (indexes, refreshToken, candidateAccountId) => {
+                const candidateId = candidateAccountId?.trim() || undefined;
+                const matches = indexes.byRefreshTokenNoOrg.get(refreshToken);
+                if (!matches || matches.length === 0)
+                    return undefined;
+                let newestNoAccountId;
+                let newestExactAccountId;
+                for (const index of matches) {
+                    const existing = accounts[index];
+                    const existingAccountId = normalizeStoredAccountId(existing);
+                    if (!existingAccountId) {
+                        newestNoAccountId =
+                            typeof newestNoAccountId === "number"
+                                ? pickNewestAccountIndex(newestNoAccountId, index)
+                                : index;
+                        continue;
+                    }
+                    if (candidateId && existingAccountId === candidateId) {
+                        newestExactAccountId =
+                            typeof newestExactAccountId === "number"
+                                ? pickNewestAccountIndex(newestExactAccountId, index)
+                                : index;
+                    }
+                }
+                return newestExactAccountId ?? newestNoAccountId;
+            };
             const resolveUniqueOrgScopedMatch = (indexes, accountId, refreshToken) => {
                 const byAccountId = accountId
                     ? asUniqueIndex(indexes.byAccountIdOrgScoped.get(accountId))
@@ -378,12 +465,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     const accountId = account.accountId?.trim();
                     const refreshToken = account.refreshToken?.trim();
                     const email = account.email?.trim();
-                    // Global refresh token index: first entry wins (keeps earliest/primary).
-                    if (refreshToken && !byRefreshTokenGlobal.has(refreshToken)) {
-                        byRefreshTokenGlobal.set(refreshToken, i);
+                    // Track all refresh-token matches. Callers can require uniqueness
+                    // so org variants that share a token do not collapse accidentally.
+                    if (refreshToken) {
+                        pushIndex(byRefreshTokenGlobal, refreshToken, i);
                     }
                     if (organizationId) {
-                        byOrganizationId.set(organizationId, i);
+                        pushIndex(byOrganizationId, organizationId, i);
                         if (accountId) {
                             pushIndex(byAccountIdOrgScoped, accountId, i);
                         }
@@ -396,7 +484,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         byAccountIdNoOrg.set(accountId, i);
                     }
                     if (refreshToken) {
-                        byRefreshTokenNoOrg.set(refreshToken, i);
+                        pushIndex(byRefreshTokenNoOrg, refreshToken, i);
                     }
                     if (email) {
                         byEmailNoOrg.set(email, i);
@@ -425,7 +513,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                 const accountEmail = sanitizeEmail(extractAccountEmail(result.access, result.idToken));
                 const existingIndex = (() => {
                     if (organizationId) {
-                        return identityIndexes.byOrganizationId.get(organizationId);
+                        return resolveOrganizationMatch(identityIndexes, organizationId, normalizedAccountId);
                     }
                     if (normalizedAccountId) {
                         const byAccountId = identityIndexes.byAccountIdNoOrg.get(normalizedAccountId);
@@ -433,11 +521,11 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             return byAccountId;
                         }
                     }
-                    const byRefreshToken = identityIndexes.byRefreshTokenNoOrg.get(result.refresh);
+                    const byRefreshToken = resolveNoOrgRefreshMatch(identityIndexes, result.refresh, normalizedAccountId);
                     if (byRefreshToken !== undefined) {
                         return byRefreshToken;
                     }
-                    if (accountEmail) {
+                    if (accountEmail && !normalizedAccountId) {
                         const byEmail = identityIndexes.byEmailNoOrg.get(accountEmail);
                         if (byEmail !== undefined) {
                             return byEmail;
@@ -446,9 +534,17 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     const orgScoped = resolveUniqueOrgScopedMatch(identityIndexes, normalizedAccountId, result.refresh);
                     if (orgScoped !== undefined)
                         return orgScoped;
-                    // Absolute last resort: same refresh token = same human account.
-                    // Catches org-scoped entries invisible to no-org lookups.
-                    return identityIndexes.byRefreshTokenGlobal.get(result.refresh);
+                    // Absolute last resort: only collapse when refresh token maps to a
+                    // single compatible account. Avoids merging distinct workspace variants.
+                    const globalRefreshMatch = asUniqueIndex(identityIndexes.byRefreshTokenGlobal.get(result.refresh));
+                    if (globalRefreshMatch === undefined) {
+                        return undefined;
+                    }
+                    const existing = accounts[globalRefreshMatch];
+                    if (!canCollapseWithCandidateAccountId(existing, normalizedAccountId)) {
+                        return undefined;
+                    }
+                    return globalRefreshMatch;
                 })();
                 if (existingIndex === undefined) {
                     accounts.push({
@@ -502,6 +598,50 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
             const pruneRefreshTokenCollisions = () => {
                 const indicesToRemove = new Set();
                 const refreshMap = new Map();
+                const pickPreferredOrgIndex = (existingIndex, candidateIndex) => {
+                    if (existingIndex === undefined)
+                        return candidateIndex;
+                    return pickNewestAccountIndex(existingIndex, candidateIndex);
+                };
+                const collapseFallbackIntoPreferredOrg = (entry) => {
+                    if (entry.preferredOrgIndex === undefined) {
+                        return;
+                    }
+                    const preferredOrgIndex = entry.preferredOrgIndex;
+                    const collapseFallbackIndex = (fallbackIndex) => {
+                        if (preferredOrgIndex === fallbackIndex)
+                            return true;
+                        const target = accounts[preferredOrgIndex];
+                        const source = accounts[fallbackIndex];
+                        if (!target || !source)
+                            return true;
+                        const targetAccountId = normalizeStoredAccountId(target);
+                        const sourceAccountId = normalizeStoredAccountId(source);
+                        if (!targetAccountId && sourceAccountId) {
+                            return false;
+                        }
+                        if (hasDistinctNonEmptyAccountIds(target, source)) {
+                            return false;
+                        }
+                        mergeAccountRecords(preferredOrgIndex, fallbackIndex);
+                        indicesToRemove.add(fallbackIndex);
+                        return true;
+                    };
+                    if (typeof entry.fallbackNoAccountIdIndex === "number") {
+                        if (collapseFallbackIndex(entry.fallbackNoAccountIdIndex)) {
+                            entry.fallbackNoAccountIdIndex = undefined;
+                        }
+                    }
+                    const fallbackAccountIdsToDelete = [];
+                    for (const [accountId, fallbackIndex] of entry.fallbackByAccountId) {
+                        if (collapseFallbackIndex(fallbackIndex)) {
+                            fallbackAccountIdsToDelete.push(accountId);
+                        }
+                    }
+                    for (const accountId of fallbackAccountIdsToDelete) {
+                        entry.fallbackByAccountId.delete(accountId);
+                    }
+                };
                 for (let i = 0; i < accounts.length; i += 1) {
                     const account = accounts[i];
                     if (!account)
@@ -512,49 +652,70 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     const orgKey = account.organizationId?.trim() ?? "";
                     let entry = refreshMap.get(refreshToken);
                     if (!entry) {
-                        entry = { byOrg: new Map(), fallbackIndex: undefined };
+                        entry = {
+                            byOrg: new Map(),
+                            preferredOrgIndex: undefined,
+                            fallbackNoAccountIdIndex: undefined,
+                            fallbackByAccountId: new Map(),
+                        };
                         refreshMap.set(refreshToken, entry);
                     }
                     if (orgKey) {
-                        const existingIndex = entry.byOrg.get(orgKey);
+                        const orgMatches = entry.byOrg.get(orgKey) ?? [];
+                        const existingIndex = resolveOrganizationMatch({
+                            byOrganizationId: new Map([[orgKey, orgMatches]]),
+                            byAccountIdNoOrg: new Map(),
+                            byRefreshTokenNoOrg: new Map(),
+                            byEmailNoOrg: new Map(),
+                            byAccountIdOrgScoped: new Map(),
+                            byRefreshTokenOrgScoped: new Map(),
+                            byRefreshTokenGlobal: new Map(),
+                        }, orgKey, normalizeStoredAccountId(account));
                         if (existingIndex !== undefined) {
                             const newestIndex = pickNewestAccountIndex(existingIndex, i);
                             const obsoleteIndex = newestIndex === existingIndex ? i : existingIndex;
                             mergeAccountRecords(newestIndex, obsoleteIndex);
                             indicesToRemove.add(obsoleteIndex);
-                            entry.byOrg.set(orgKey, newestIndex);
+                            const nextOrgMatches = orgMatches.filter((index) => index !== obsoleteIndex && index !== newestIndex);
+                            nextOrgMatches.push(newestIndex);
+                            entry.byOrg.set(orgKey, nextOrgMatches);
+                            entry.preferredOrgIndex = pickPreferredOrgIndex(entry.preferredOrgIndex, newestIndex);
+                            collapseFallbackIntoPreferredOrg(entry);
                             continue;
                         }
-                        entry.byOrg.set(orgKey, i);
+                        entry.byOrg.set(orgKey, [...orgMatches, i]);
+                        entry.preferredOrgIndex = pickPreferredOrgIndex(entry.preferredOrgIndex, i);
+                        collapseFallbackIntoPreferredOrg(entry);
                         continue;
                     }
-                    const existingFallback = entry.fallbackIndex;
+                    const fallbackAccountId = normalizeStoredAccountId(account);
+                    if (fallbackAccountId) {
+                        const existingFallback = entry.fallbackByAccountId.get(fallbackAccountId);
+                        if (typeof existingFallback === "number") {
+                            const newestIndex = pickNewestAccountIndex(existingFallback, i);
+                            const obsoleteIndex = newestIndex === existingFallback ? i : existingFallback;
+                            mergeAccountRecords(newestIndex, obsoleteIndex);
+                            indicesToRemove.add(obsoleteIndex);
+                            entry.fallbackByAccountId.set(fallbackAccountId, newestIndex);
+                            collapseFallbackIntoPreferredOrg(entry);
+                            continue;
+                        }
+                        entry.fallbackByAccountId.set(fallbackAccountId, i);
+                        collapseFallbackIntoPreferredOrg(entry);
+                        continue;
+                    }
+                    const existingFallback = entry.fallbackNoAccountIdIndex;
                     if (typeof existingFallback === "number") {
                         const newestIndex = pickNewestAccountIndex(existingFallback, i);
                         const obsoleteIndex = newestIndex === existingFallback ? i : existingFallback;
                         mergeAccountRecords(newestIndex, obsoleteIndex);
                         indicesToRemove.add(obsoleteIndex);
-                        entry.fallbackIndex = newestIndex;
+                        entry.fallbackNoAccountIdIndex = newestIndex;
+                        collapseFallbackIntoPreferredOrg(entry);
                         continue;
                     }
-                    entry.fallbackIndex = i;
-                }
-                for (const entry of refreshMap.values()) {
-                    const fallbackIndex = entry.fallbackIndex;
-                    if (typeof fallbackIndex !== "number")
-                        continue;
-                    const orgIndices = Array.from(entry.byOrg.values());
-                    if (orgIndices.length === 0)
-                        continue;
-                    const [firstOrgIndex, ...otherOrgIndices] = orgIndices;
-                    if (typeof firstOrgIndex !== "number")
-                        continue;
-                    let preferredOrgIndex = firstOrgIndex;
-                    for (const orgIndex of otherOrgIndices) {
-                        preferredOrgIndex = pickNewestAccountIndex(preferredOrgIndex, orgIndex);
-                    }
-                    mergeAccountRecords(preferredOrgIndex, fallbackIndex);
-                    indicesToRemove.add(fallbackIndex);
+                    entry.fallbackNoAccountIdIndex = i;
+                    collapseFallbackIntoPreferredOrg(entry);
                 }
                 if (indicesToRemove.size > 0) {
                     accounts = accounts.filter((_, index) => !indicesToRemove.has(index));
@@ -621,7 +782,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
             const activeIndex = remappedActiveIndex ?? fallbackActiveIndex;
             const clampedActiveIndex = Math.max(0, Math.min(Math.floor(activeIndex), accounts.length - 1));
             const activeIndexByFamily = {};
-            for (const family of MODEL_FAMILIES) {
+            const familiesToPersist = replaceAll
+                ? []
+                : MODEL_FAMILIES.filter((family) => {
+                    const storedFamilyIndex = stored?.activeIndexByFamily?.[family];
+                    return typeof storedFamilyIndex === "number" && Number.isFinite(storedFamilyIndex);
+                });
+            for (const family of familiesToPersist) {
                 const storedFamilyIndex = stored?.activeIndexByFamily?.[family];
                 const remappedFamilyIndex = replaceAll
                     ? undefined