@pasko70/pibo 1.7.8 → 1.7.9

package/dist/providers/openai-gpt56.js

@@ -1,13 +1,15 @@
 import { getModels } from "@mariozechner/pi-ai";
+import { getOAuthProvider } from "@mariozechner/pi-ai/oauth";
 export const OPENAI_PROVIDER_ID = "openai";
 export const OPENAI_RESPONSES_API = "openai-responses";
 export const OPENAI_BASE_URL = "https://api.openai.com/v1";
 export const OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
-const GPT_56_CONTEXT_WINDOW = 1_050_000;
+export const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
+export const OPENAI_CODEX_RESPONSES_API = "openai-codex-responses";
+export const OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const OPENAI_GPT_56_CONTEXT_WINDOW = 1_050_000;
+const OPENAI_CODEX_GPT_56_CONTEXT_WINDOW = 272_000;
 const GPT_56_MAX_TOKENS = 128_000;
-// Register GPT-5.6 on the normal OpenAI API provider only.
-// This keeps Pibo on the existing token-plan path (OPENAI_API_KEY) and does not
-// route these models through ChatGPT/Codex OAuth (`openai-codex`).
 export const OPENAI_GPT_56_MODELS = [
     {
         id: "gpt-5.6",
@@ -30,62 +32,122 @@ export const OPENAI_GPT_56_MODELS = [
         cost: { input: 1, output: 6, cacheRead: 0.1, cacheWrite: 1.25 },
     },
 ];
+const OPENAI_GPT_56_MODEL_IDS = new Set(OPENAI_GPT_56_MODELS.map((model) => model.id));
 export function getBuiltInOpenAiModels() {
-    try {
-        return getModels(OPENAI_PROVIDER_ID);
-    }
-    catch {
-        return [];
-    }
+    return getBuiltInProviderModels(OPENAI_PROVIDER_ID);
+}
+export function getBuiltInOpenAiCodexModels() {
+    return getBuiltInProviderModels(OPENAI_CODEX_PROVIDER_ID);
 }
 export function buildOpenAiGpt56Models(baseModels = getBuiltInOpenAiModels()) {
-    const openAiBaseModels = baseModels
-        .filter((model) => model.provider === OPENAI_PROVIDER_ID)
-        .map((model) => ({
-        ...model,
-        input: [...model.input],
-        cost: { ...model.cost },
-        headers: model.headers ? { ...model.headers } : undefined,
-        compat: model.compat ? { ...model.compat } : undefined,
-    }));
-    const existingIds = new Set(openAiBaseModels.map((model) => model.id));
-    const additions = OPENAI_GPT_56_MODELS
-        .filter((model) => !existingIds.has(model.id))
-        .map(openAiGpt56ModelToRegistryModel);
-    return [...openAiBaseModels, ...additions];
+    return buildProviderGpt56Models({
+        providerId: OPENAI_PROVIDER_ID,
+        api: OPENAI_RESPONSES_API,
+        baseUrl: OPENAI_BASE_URL,
+        contextWindow: OPENAI_GPT_56_CONTEXT_WINDOW,
+        thinkingLevelMap: { off: null, xhigh: "xhigh" },
+        baseModels,
+        modelCost: (model) => model.cost,
+    });
+}
+export function buildOpenAiCodexGpt56Models(baseModels = getBuiltInOpenAiCodexModels()) {
+    return buildProviderGpt56Models({
+        providerId: OPENAI_CODEX_PROVIDER_ID,
+        api: OPENAI_CODEX_RESPONSES_API,
+        baseUrl: OPENAI_CODEX_BASE_URL,
+        contextWindow: OPENAI_CODEX_GPT_56_CONTEXT_WINDOW,
+        thinkingLevelMap: { xhigh: "xhigh", minimal: "low" },
+        baseModels,
+        modelCost: (model) => ({ ...model.cost, cacheWrite: 0 }),
+    });
 }
 export function registerOpenAiGpt56Models(modelRegistry, options = {}) {
-    const baseModels = options.baseModels ?? getBuiltInOpenAiModels();
-    const models = buildOpenAiGpt56Models(baseModels);
-    const baseOpenAiIds = new Set(baseModels.filter((model) => model.provider === OPENAI_PROVIDER_ID).map((model) => model.id));
-    const added = OPENAI_GPT_56_MODELS.filter((model) => !baseOpenAiIds.has(model.id)).length;
+    const baseOpenAiModels = options.baseOpenAiModels ?? getBuiltInOpenAiModels();
+    const openAiModels = buildOpenAiGpt56Models(baseOpenAiModels);
+    const openAiAdded = countMissingGpt56Models(baseOpenAiModels, OPENAI_PROVIDER_ID);
     modelRegistry.registerProvider(OPENAI_PROVIDER_ID, {
         baseUrl: OPENAI_BASE_URL,
         api: OPENAI_RESPONSES_API,
         apiKey: OPENAI_API_KEY_ENV,
-        models,
+        models: openAiModels,
+    });
+    const baseOpenAiCodexModels = options.baseOpenAiCodexModels ?? getBuiltInOpenAiCodexModels();
+    const openAiCodexModels = buildOpenAiCodexGpt56Models(baseOpenAiCodexModels);
+    const openAiCodexAdded = countMissingGpt56Models(baseOpenAiCodexModels, OPENAI_CODEX_PROVIDER_ID);
+    const openAiCodexOAuth = getOpenAiCodexOAuthConfig();
+    modelRegistry.registerProvider(OPENAI_CODEX_PROVIDER_ID, {
+        name: openAiCodexOAuth.name,
+        baseUrl: OPENAI_CODEX_BASE_URL,
+        api: OPENAI_CODEX_RESPONSES_API,
+        oauth: openAiCodexOAuth,
+        models: openAiCodexModels,
     });
-    return { registered: true, models: models.length, added };
+    return {
+        registered: true,
+        providers: 2,
+        models: openAiModels.length + openAiCodexModels.length,
+        added: openAiAdded + openAiCodexAdded,
+    };
 }
 export function findOpenAiGpt56Model(modelRegistry, model) {
-    if (model?.provider !== OPENAI_PROVIDER_ID || !model.id)
+    if (!model?.provider || !model.id)
+        return undefined;
+    if (model.provider !== OPENAI_PROVIDER_ID && model.provider !== OPENAI_CODEX_PROVIDER_ID)
         return undefined;
-    if (!OPENAI_GPT_56_MODELS.some((candidate) => candidate.id === model.id))
+    if (!OPENAI_GPT_56_MODEL_IDS.has(model.id))
         return undefined;
-    return modelRegistry.find(OPENAI_PROVIDER_ID, model.id);
+    return modelRegistry.find(model.provider, model.id);
 }
-function openAiGpt56ModelToRegistryModel(model) {
+function getBuiltInProviderModels(providerId) {
+    try {
+        return getModels(providerId);
+    }
+    catch {
+        return [];
+    }
+}
+function buildProviderGpt56Models(options) {
+    const providerBaseModels = options.baseModels
+        .filter((model) => model.provider === options.providerId)
+        .map(cloneModel);
+    const existingIds = new Set(providerBaseModels.map((model) => model.id));
+    const additions = OPENAI_GPT_56_MODELS
+        .filter((model) => !existingIds.has(model.id))
+        .map((model) => openAiGpt56ModelToRegistryModel(model, options));
+    return [...providerBaseModels, ...additions];
+}
+function countMissingGpt56Models(baseModels, providerId) {
+    const existingIds = new Set(baseModels.filter((model) => model.provider === providerId).map((model) => model.id));
+    return OPENAI_GPT_56_MODELS.filter((model) => !existingIds.has(model.id)).length;
+}
+function cloneModel(model) {
+    return {
+        ...model,
+        input: [...model.input],
+        cost: { ...model.cost },
+        headers: model.headers ? { ...model.headers } : undefined,
+        compat: model.compat ? { ...model.compat } : undefined,
+    };
+}
+function openAiGpt56ModelToRegistryModel(model, options) {
     return {
         id: model.id,
         name: model.name,
-        api: OPENAI_RESPONSES_API,
-        provider: OPENAI_PROVIDER_ID,
-        baseUrl: OPENAI_BASE_URL,
+        api: options.api,
+        provider: options.providerId,
+        baseUrl: options.baseUrl,
         reasoning: true,
-        thinkingLevelMap: { off: null, xhigh: "xhigh" },
+        thinkingLevelMap: options.thinkingLevelMap,
         input: ["text", "image"],
-        cost: { ...model.cost },
-        contextWindow: GPT_56_CONTEXT_WINDOW,
+        cost: options.modelCost(model),
+        contextWindow: options.contextWindow,
         maxTokens: GPT_56_MAX_TOKENS,
     };
 }
+function getOpenAiCodexOAuthConfig() {
+    const provider = getOAuthProvider(OPENAI_CODEX_PROVIDER_ID);
+    if (!provider)
+        throw new Error("OpenAI Codex OAuth provider is unavailable.");
+    const { id: _id, ...oauth } = provider;
+    return oauth;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.7.8",
+  "version": "1.7.9",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"