OMP rewrites @earendil-works/pi-ai/compat to a bundle without registerApiProvider, which broke static import at install/load. Probe the export at runtime; stock pi still registers qoder-api for global streamSimple, while OMP relies on registerProvider(streamSimple).
132 lines
5.4 KiB
TypeScript
132 lines
5.4 KiB
TypeScript
import type { Api, Model, OAuthCredentials } from "@earendil-works/pi-ai";
|
|
import type { ExtensionAPI, ProviderConfig } from "@earendil-works/pi-coding-agent";
|
|
import {
|
|
autoLoginQoderFromEnvironment,
|
|
getCachedCredentials,
|
|
loginQoderForMode,
|
|
refreshQoderTokenForMode,
|
|
} from "./auth/oauth.js";
|
|
import { fetchQoderUsageForMode } from "./auth/usage.js";
|
|
import { getCachedModels, isCacheStale, staticCnModels, staticModels, updateQoderModelsCache } from "./catalog.js";
|
|
import { streamQoder } from "./protocol/stream.js";
|
|
import { getQoderBaseUrl, getQoderRegionConfig, QODER_MODES, type QoderMode } from "./region.js";
|
|
|
|
// pi supports a `fetchUsage` hook on the oauth config at runtime, but it is not
|
|
// part of the published ProviderConfig type. Declare the extension locally.
|
|
type OAuthConfigWithUsage = NonNullable<ProviderConfig["oauth"]> & {
|
|
fetchUsage: (credentials: OAuthCredentials) => Promise<unknown>;
|
|
};
|
|
|
|
const QODER_API = "qoder-api" as Api;
|
|
|
|
async function registerQoderApi(): Promise<void> {
|
|
try {
|
|
const compat = await import("@earendil-works/pi-ai/compat");
|
|
const register = (compat as Record<string, unknown>).registerApiProvider;
|
|
if (typeof register !== "function") return; // OMP / hosts without the export
|
|
(register as (config: unknown, source: string) => void)(
|
|
{ api: QODER_API, stream: streamQoder, streamSimple: streamQoder },
|
|
"provider:qoder",
|
|
);
|
|
} catch {
|
|
// Host has no compat registry; registerProvider(streamSimple) is enough.
|
|
}
|
|
}
|
|
|
|
function modelsForProvider(mode: QoderMode, providerID: string): Model<Api>[] {
|
|
const cached = getCachedModels(mode);
|
|
const modelsToUse = cached.length > 0 ? cached : mode === "cn" ? staticCnModels : staticModels;
|
|
|
|
return modelsToUse.map((m) => ({
|
|
...m,
|
|
provider: providerID,
|
|
baseUrl: getQoderBaseUrl(mode),
|
|
})) as unknown as Model<Api>[];
|
|
}
|
|
|
|
function createQoderOAuth(mode: QoderMode): OAuthConfigWithUsage {
|
|
const region = getQoderRegionConfig(mode);
|
|
return {
|
|
name: region.loginName,
|
|
login: (callbacks) => loginQoderForMode(callbacks, mode),
|
|
refreshToken: (credentials) => refreshQoderTokenForMode(credentials, mode),
|
|
getApiKey: (cred: OAuthCredentials) => cred.access,
|
|
// NOTE: no `modifyModels` hook on purpose. OMP (Bun) does a whole-catalog
|
|
// structuredClone before invoking it, and its bundled catalog contains a
|
|
// model with a non-cloneable property -> "The object can not be cloned."
|
|
// removes qoder from `omp models`. Models are supplied at registration
|
|
// via `modelsForProvider` and refreshed by the startup/session cache hooks.
|
|
fetchUsage: (credentials) => fetchQoderUsageForMode(credentials, mode),
|
|
};
|
|
}
|
|
|
|
function registerQoderProvider(pi: ExtensionAPI, mode: QoderMode): void {
|
|
const providerID = getQoderRegionConfig(mode).providerID;
|
|
const oauth = createQoderOAuth(mode);
|
|
pi.registerProvider(providerID, {
|
|
baseUrl: getQoderBaseUrl(mode),
|
|
api: QODER_API,
|
|
models: modelsForProvider(mode, providerID) as unknown as ProviderConfig["models"],
|
|
oauth: oauth as ProviderConfig["oauth"],
|
|
// pi-coding-agent resolves its own nested @earendil-works/pi-ai copy, so the
|
|
// structurally identical Model/Context types are nominally distinct here.
|
|
streamSimple: streamQoder as unknown as ProviderConfig["streamSimple"],
|
|
});
|
|
}
|
|
|
|
async function refreshModelsAtStartup(mode: QoderMode): Promise<void> {
|
|
const providerID = getQoderRegionConfig(mode).providerID;
|
|
if (!isCacheStale(mode)) return;
|
|
|
|
const credentials = getCachedCredentials("", providerID);
|
|
if (!credentials?.access) return;
|
|
|
|
const region = getQoderRegionConfig(mode);
|
|
await updateQoderModelsCache(
|
|
credentials.access,
|
|
credentials.userID || "qoder-user",
|
|
credentials.name || region.userNameFallback,
|
|
credentials.email || region.userEmailFallback,
|
|
mode,
|
|
);
|
|
}
|
|
|
|
export default async function (pi: ExtensionAPI) {
|
|
await registerQoderApi();
|
|
|
|
for (const mode of QODER_MODES) {
|
|
const providerID = getQoderRegionConfig(mode).providerID;
|
|
try {
|
|
await autoLoginQoderFromEnvironment(providerID, mode);
|
|
await refreshModelsAtStartup(mode);
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
console.error(`[pi-provider-qoder] Automatic login failed for ${providerID}: ${message}`);
|
|
}
|
|
}
|
|
|
|
// Refresh the models cache once per session at startup if it is missing or
|
|
// stale (>1h old), rather than on every message in the stream hot path.
|
|
// Login/refresh are the other rebuild triggers; this covers the case where
|
|
// the cache was deleted while the token is still valid.
|
|
pi.on("session_start", async (_event, ctx) => {
|
|
for (const mode of QODER_MODES) {
|
|
try {
|
|
const region = getQoderRegionConfig(mode);
|
|
const providerID = region.providerID;
|
|
const accessToken = await ctx.modelRegistry.getApiKeyForProvider(providerID);
|
|
if (!accessToken || !isCacheStale(mode)) continue;
|
|
const creds = getCachedCredentials(accessToken, providerID);
|
|
const userID = creds?.userID || "qoder-user";
|
|
const name = creds?.name || region.userNameFallback;
|
|
const email = creds?.email || region.userEmailFallback;
|
|
await updateQoderModelsCache(accessToken, userID, name, email, mode);
|
|
} catch {
|
|
// Best-effort: fall back to the existing cache / static models.
|
|
}
|
|
}
|
|
});
|
|
|
|
for (const mode of QODER_MODES) registerQoderProvider(pi, mode);
|
|
}
|