pi-devin-auth 0.1.0 → 0.1.2

package/extensions/index.ts

@@ -4,13 +4,15 @@
  * Registers the `devin` provider with pi's ExtensionAPI, wiring up:
  *  - OAuth login via Windsurf's browser sign-in flow (`loginDevin`)
  *  - A no-op token refresh (Windsurf api_keys are long-lived)
- *  - Static model list (dynamic catalog fetch planned for a future version
- *    once we've inspected the gRPC GetCascadeModelConfigs response shape)
+ *  - Live model catalog fetch from Cognition's GetCascadeModelConfigs
+ *    after login, filtered to 11 wanted model families
+ *  - `/devin-refresh` command to manually re-fetch the catalog
+ *  - `/devin-status` command to check auth state
+ *  - `session_start` auto-fetch when already logged in
  *  - Streaming chat completions through Devin Cloud (`streamDevin`)
  *
- * The provider does not set baseUrl/apiKey at the provider level —
- * `streamSimple` handles all routing and auth internally using the
- * OAuth-issued api_key.
+ * The provider uses `streamSimple` — no background proxy. All routing
+ * and auth are handled internally via the OAuth-issued api_key.
  */
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
@@ -22,44 +24,51 @@ import type {
 } from '@earendil-works/pi-ai';
 import { streamDevin } from '../src/stream.js';
 import { loginDevin } from '../src/oauth/login.js';
-import { FALLBACK_MODELS } from '../src/models.js';
+import { buildLiveModels, FALLBACK_MODELS, DEFAULT_HOST } from '../src/models.js';
+import { getCachedCatalog, clearCachedCatalog } from '../src/cloud-direct/catalog.js';
 import { DEFAULT_REGION } from '../src/oauth/types.js';
 
 const PROVIDER_ID = 'devin';
 const PROVIDER_NAME = 'Devin (Cognition)';
 const OAUTH_NAME = 'Devin (Cognition / Windsurf)';
 const API_IDENTIFIER = 'devin-cloud';
+// pi requires baseUrl when models are defined, even with streamSimple.
+// streamSimple ignores this — it routes internally — but the field must be present.
+const PLACEHOLDER_BASE_URL = DEFAULT_HOST;
 
-export default async function (pi: ExtensionAPI): Promise<void> {
+let _pi: ExtensionAPI | null = null;
+
+function registerDevinProvider(pi: ExtensionAPI, models: typeof FALLBACK_MODELS): void {
     pi.registerProvider(PROVIDER_ID, {
         name: PROVIDER_NAME,
         api: API_IDENTIFIER,
-        // No baseUrl/apiKey at the provider level — streamSimple handles
-        // all routing and auth internally via the OAuth-issued api_key.
-        models: FALLBACK_MODELS,
+        baseUrl: PLACEHOLDER_BASE_URL,
+        models,
         oauth: {
             name: OAUTH_NAME,
-            async login(
-                callbacks: OAuthLoginCallbacks,
-            ): Promise<OAuthCredentials> {
-                return loginDevin(callbacks, DEFAULT_REGION);
+            async login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+                const credentials = await loginDevin(callbacks, DEFAULT_REGION);
+                if (_pi) {
+                    try {
+                        clearCachedCatalog();
+                        const catalog = await getCachedCatalog(
+                            credentials.access,
+                            DEFAULT_HOST,
+                        );
+                        const liveModels = buildLiveModels(catalog);
+                        registerDevinProvider(_pi, liveModels);
+                    } catch {
+                        // keep static models if catalog fetch fails
+                    }
+                }
+                return credentials;
             },
-            async refreshToken(
-                credentials: OAuthCredentials,
-            ): Promise<OAuthCredentials> {
-                // Windsurf's RegisterUser returns a long-lived api_key
-                // with no refresh token. The key is effectively
-                // non-expiring, so refreshToken is a no-op — return the
-                // same credentials.
+            async refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
                 return credentials;
             },
             getApiKey(credentials: OAuthCredentials): string {
                 return credentials.access;
             },
-            // modifyModels is sync in pi v0.80.x, so we can't do an async
-            // catalog fetch here. The static FALLBACK_MODELS list is used
-            // for v0.1.0. Dynamic catalog fetch will be added in a future
-            // version once we've verified the gRPC response shape.
             modifyModels(models: Model<Api>[]): Model<Api>[] {
                 return models;
             },
@@ -67,3 +76,66 @@ export default async function (pi: ExtensionAPI): Promise<void> {
         streamSimple: streamDevin,
     });
 }
+
+export default async function (pi: ExtensionAPI): Promise<void> {
+    _pi = pi;
+
+    registerDevinProvider(pi, FALLBACK_MODELS);
+
+    pi.on('session_start', async (_event, ctx) => {
+        try {
+            const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+            if (apiKey && _pi) {
+                const catalog = await getCachedCatalog(apiKey, DEFAULT_HOST);
+                const liveModels = buildLiveModels(catalog);
+                registerDevinProvider(_pi, liveModels);
+            }
+        } catch {
+            // keep static models
+        }
+    });
+
+    pi.registerCommand('devin-refresh', {
+        description: 'Refresh Devin model catalog from Cognition',
+        handler: async (_args, ctx) => {
+            const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+            if (!apiKey) {
+                ctx.ui.notify(
+                    'Devin: not signed in. Run /login devin',
+                    'warning',
+                );
+                return;
+            }
+            clearCachedCatalog();
+            try {
+                const catalog = await getCachedCatalog(apiKey, DEFAULT_HOST);
+                const liveModels = buildLiveModels(catalog);
+                registerDevinProvider(pi, liveModels);
+                ctx.ui.notify(
+                    `Devin: refreshed ${liveModels.length} models.`,
+                    'info',
+                );
+            } catch (e) {
+                ctx.ui.notify(
+                    `Devin: refresh error - ${e instanceof Error ? e.message : String(e)}`,
+                    'error',
+                );
+            }
+        },
+    });
+
+    pi.registerCommand('devin-status', {
+        description: 'Show Devin auth status',
+        handler: async (_args, ctx) => {
+            const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+            ctx.ui.notify(
+                apiKey ? 'Devin: authenticated' : 'Devin: not signed in. Run /login devin',
+                apiKey ? 'info' : 'warning',
+            );
+        },
+    });
+
+    pi.on('session_shutdown', async () => {
+        _pi = null;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-devin-auth",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Pi coding agent extension for Devin/Cognition (Windsurf) OAuth + streaming",
   "type": "module",
   "keywords": [

package/src/cloud-direct/catalog.ts

@@ -60,7 +60,7 @@ export interface ModelCatalogEntry {
   disabled: boolean;
 }
 
-interface CacheEntry {
+export interface CacheEntry {
   /** Lookup keyed by `model_uid`. */
   byUid: Map<string, ModelCatalogEntry>;
   fetchedAt: number;

package/src/cloud-direct/index.ts

@@ -37,4 +37,5 @@ export {
   clearCachedCatalog,
   ModelNotAvailableError,
   type ModelCatalogEntry,
+  type CacheEntry,
 } from './catalog.js';

package/src/models.ts

@@ -1,135 +1,236 @@
 /**
- * Resolve the model list for the Devin provider.
+ * Model list for the Devin (Cognition) provider.
  *
- * Fetches the per-account catalog from Cognition's gRPC
- * `GetCascadeModelConfigs` (via {@link getCachedCatalog}) and maps it to
- * pi's {@link ProviderModelConfig} shape. When the fetch fails (offline,
- * auth error, transient outage) or the catalog comes back empty, we hand
- * back {@link FALLBACK_MODELS} so the extension can still show a model
- * picker before login.
+ * Two paths:
+ *   1. {@link FALLBACK_MODELS} — 11 static entries shown before login or
+ *      when the live catalog fetch fails. Carries real pricing.
+ *   2. {@link buildLiveModels} — filters the live `GetCascadeModelConfigs`
+ *      catalog to the 11 model families we care about, stamping each entry
+ *      with pricing/metadata from {@link MODEL_OVERRIDES}.
  *
  * The catalog only carries `modelUid`, `label`, and `disabled` — it does
- * NOT include context window, max output tokens, or reasoning capability.
- * For known popular models we override those fields from
- * {@link MODEL_OVERRIDES}; unknown UIDs get conservative defaults from
- * the `DEFAULT_*` constants below.
+ * NOT include context window, max output tokens, reasoning capability, or
+ * pricing. We supply all of those from {@link MODEL_OVERRIDES}, keyed by
+ * prefix so variants (e.g. `claude-opus-4-8-medium`, `gpt-5-6-sol-low`)
+ * inherit the correct metadata from their parent family.
  */
 
 import type { ProviderModelConfig } from '@earendil-works/pi-coding-agent';
-import { getCachedCatalog } from './cloud-direct/catalog.js';
+import type { CacheEntry } from './cloud-direct/index.js';
 
 /** Default Cognition/Codeium host. */
 const DEFAULT_HOST = 'https://server.codeium.com';
 
 /**
- * Static fallback list used when the catalog is null or empty (offline,
- * auth error, pre-login). All free for now — pricing TBD.
+ * Prefixes of the 11 model families we want from the live catalog.
+ * Prefix matching catches variants (e.g. `swe-1-7-lightning`,
+ * `gpt-5-6-sol-low`, `claude-opus-4-8-high`).
  */
-export const FALLBACK_MODELS: ProviderModelConfig[] = [
-  {
-    id: 'swe-1-6',
-    name: 'SWE 1.6',
-    reasoning: true,
-    input: ['text', 'image'],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 256000,
-    maxTokens: 128000,
-  },
-  {
-    id: 'swe-1-6-slow',
-    name: 'SWE 1.6 (Slow)',
-    reasoning: true,
-    input: ['text', 'image'],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 256000,
-    maxTokens: 128000,
-  },
-  {
-    id: 'kimi-k2-6',
-    name: 'Kimi K2.6',
-    reasoning: true,
-    input: ['text', 'image'],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 256000,
-    maxTokens: 128000,
-  },
+export const WANTED_PREFIXES: readonly string[] = [
+    'swe-1-7',
+    'gpt-5-6-sol',
+    'gpt-5-6-luna',
+    'gpt-5-6-terra',
+    'claude-opus-4-8',
+    'claude-fable-5',
+    'claude-sonnet-5',
+    'glm-5-2',
+    'kimi-k2-7',
+    'grok-4-5',
 ];
 
-/** Per-model metadata override. All fields optional; missing ones use defaults. */
-interface ModelOverride {
-  contextWindow?: number;
-  maxTokens?: number;
-  reasoning?: boolean;
-  input?: ('text' | 'image')[];
+function matchesWantedPrefix(uid: string): boolean {
+    for (const prefix of WANTED_PREFIXES) {
+        if (uid === prefix || uid.startsWith(prefix + '-') || uid.startsWith(prefix + '_')) {
+            return true;
+        }
+    }
+    return false;
 }
 
 /**
- * Known-model override table. Cognition's catalog only returns
- * `modelUid`/`label`/`disabled`, so for UIDs we recognise we supply
- * accurate context window, max output tokens, reasoning flag, and input
- * modalities. UIDs not in this map get the `DEFAULT_*` constants.
+ * Per-model metadata + pricing, keyed by prefix.
+ *
+ * All prices are per million tokens (USD). Used by both
+ * {@link FALLBACK_MODELS} and {@link buildLiveModels} so there is a single
+ * source of truth for pricing.
  */
-const MODEL_OVERRIDES: Map<string, ModelOverride> = new Map([
-  // SWE models
-  ['swe-1-6', { contextWindow: 256000, maxTokens: 128000, reasoning: true, input: ['text', 'image'] }],
-  ['swe-1-6-slow', { contextWindow: 256000, maxTokens: 128000, reasoning: true, input: ['text', 'image'] }],
-  // Claude family
-  ['claude-opus-4-7-medium', { contextWindow: 200000, maxTokens: 128000, reasoning: true, input: ['text', 'image'] }],
-  ['claude-opus-4-7', { contextWindow: 200000, maxTokens: 128000, reasoning: true, input: ['text', 'image'] }],
-  ['claude-sonnet-4-6', { contextWindow: 200000, maxTokens: 64000, reasoning: true, input: ['text', 'image'] }],
-  ['claude-sonnet-4-5', { contextWindow: 200000, maxTokens: 16384, reasoning: true, input: ['text', 'image'] }],
-  // GPT family
-  ['gpt-5-5', { contextWindow: 272000, maxTokens: 128000, reasoning: true, input: ['text', 'image'] }],
-  ['gpt-5', { contextWindow: 128000, maxTokens: 16384, reasoning: true, input: ['text', 'image'] }],
-  // Gemini
-  ['gemini-3-0-pro', { contextWindow: 1000000, maxTokens: 65536, reasoning: true, input: ['text', 'image'] }],
-  // Kimi
-  ['kimi-k2-6', { contextWindow: 256000, maxTokens: 128000, reasoning: true, input: ['text', 'image'] }],
+interface ModelMeta {
+    contextWindow: number;
+    maxTokens: number;
+    reasoning: boolean;
+    input: ('text' | 'image')[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+}
+
+const MODEL_META: Map<string, ModelMeta> = new Map([
+    ['swe-1-7', {
+        contextWindow: 256_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    }],
+    ['swe-1-7-lightning', {
+        contextWindow: 256_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 2.50, output: 12.50, cacheRead: 0.25, cacheWrite: 3.13 },
+    }],
+    ['gpt-5-6-sol', {
+        contextWindow: 1_050_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 5.00, output: 30.00, cacheRead: 0.50, cacheWrite: 6.25 },
+    }],
+    ['gpt-5-6-luna', {
+        contextWindow: 1_050_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 1.00, output: 6.00, cacheRead: 0.10, cacheWrite: 1.25 },
+    }],
+    ['gpt-5-6-terra', {
+        contextWindow: 1_050_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 2.50, output: 15.00, cacheRead: 0.25, cacheWrite: 3.13 },
+    }],
+    ['claude-opus-4-8', {
+        contextWindow: 200_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+    }],
+    ['claude-fable-5', {
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 10.00, output: 50.00, cacheRead: 1.00, cacheWrite: 12.50 },
+    }],
+    ['claude-sonnet-5', {
+        contextWindow: 200_000,
+        maxTokens: 64_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 3.00, output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
+    }],
+    ['glm-5-2', {
+        contextWindow: 1_000_000,
+        maxTokens: 131_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 0.70, output: 2.20, cacheRead: 0.26, cacheWrite: 0.88 },
+    }],
+    ['kimi-k2-7', {
+        contextWindow: 256_000,
+        maxTokens: 256_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 0.95, output: 4.00, cacheRead: 0.19, cacheWrite: 1.19 },
+    }],
+    ['grok-4-5', {
+        contextWindow: 500_000,
+        maxTokens: 128_000,
+        reasoning: true,
+        input: ['text', 'image'],
+        cost: { input: 2.00, output: 6.00, cacheRead: 0.50, cacheWrite: 2.50 },
+    }],
 ]);
 
+/**
+ * Find the best-matching metadata for a UID by longest-prefix match
+ * against {@link MODEL_META}. This lets `swe-1-7-lightning` match the
+ * `swe-1-7-lightning` entry (specific) and `gpt-5-6-sol-low` match the
+ * `gpt-5-6-sol` entry (parent family).
+ */
+function findMeta(uid: string): ModelMeta | undefined {
+    let best: { key: string; meta: ModelMeta } | null = null;
+    for (const [key, meta] of MODEL_META) {
+        if (uid === key || uid.startsWith(key + '-') || uid.startsWith(key + '_')) {
+            if (!best || key.length > best.key.length) {
+                best = { key, meta };
+            }
+        }
+    }
+    return best?.meta;
+}
+
 /** Conservative defaults for catalog UIDs not in the override table. */
-const DEFAULT_CONTEXT_WINDOW = 256000;
-const DEFAULT_MAX_TOKENS = 128000;
-const DEFAULT_REASONING = true;
-const DEFAULT_INPUT: ('text' | 'image')[] = ['text', 'image'];
+const DEFAULT_META: ModelMeta = {
+    contextWindow: 256_000,
+    maxTokens: 128_000,
+    reasoning: true,
+    input: ['text', 'image'],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+};
+
+function makeModel(id: string, name: string, meta: ModelMeta): ProviderModelConfig {
+    return {
+        id,
+        name,
+        reasoning: meta.reasoning,
+        input: meta.input,
+        cost: meta.cost,
+        contextWindow: meta.contextWindow,
+        maxTokens: meta.maxTokens,
+    };
+}
 
 /**
- * Resolve the Devin/Cognition model list for `(apiKey, host)`.
- *
- * Flow:
- *   1. Fetch the per-account catalog via {@link getCachedCatalog}. It
- *      already returns `null` on failure; the extra `.catch(() => null)`
- *      is defense in depth for unexpected throws.
- *   2. If the catalog is null or empty, return {@link FALLBACK_MODELS} so
- *      the extension can still render a picker pre-login / offline.
- *   3. Otherwise map every non-disabled catalog entry to a
- *      {@link ProviderModelConfig}, applying per-model overrides for
- *      known UIDs and conservative defaults for the rest.
+ * Static fallback list — 11 models with real pricing.
+ * Shown before login or when the live catalog fetch fails.
+ */
+export const FALLBACK_MODELS: ProviderModelConfig[] = [
+    makeModel('swe-1-7', 'SWE-1.7', MODEL_META.get('swe-1-7')!),
+    makeModel('swe-1-7-lightning', 'SWE-1.7 Lightning', MODEL_META.get('swe-1-7-lightning')!),
+    makeModel('gpt-5-6-sol', 'GPT-5.6 Sol', MODEL_META.get('gpt-5-6-sol')!),
+    makeModel('gpt-5-6-luna', 'GPT-5.6 Luna', MODEL_META.get('gpt-5-6-luna')!),
+    makeModel('gpt-5-6-terra', 'GPT-5.6 Terra', MODEL_META.get('gpt-5-6-terra')!),
+    makeModel('claude-opus-4-8', 'Claude Opus 4.8', MODEL_META.get('claude-opus-4-8')!),
+    makeModel('claude-fable-5', 'Claude Fable 5', MODEL_META.get('claude-fable-5')!),
+    makeModel('claude-sonnet-5', 'Claude Sonnet 5', MODEL_META.get('claude-sonnet-5')!),
+    makeModel('glm-5-2', 'GLM-5.2', MODEL_META.get('glm-5-2')!),
+    makeModel('kimi-k2-7', 'Kimi K2.7', MODEL_META.get('kimi-k2-7')!),
+    makeModel('grok-4-5', 'Grok 4.5', MODEL_META.get('grok-4-5')!),
+];
+
+/**
+ * Build the model list from a live catalog response.
  *
- * All costs are 0 for now (free tier / pricing TBD).
+ * Filters to the 11 wanted families via {@link WANTED_PREFIXES}, skips
+ * disabled entries, and stamps each with pricing/metadata from
+ * {@link MODEL_META}. Falls back to {@link FALLBACK_MODELS} when the
+ * catalog is null, empty, or contains none of our wanted models.
  */
-export async function resolveModels(
-  apiKey: string,
-  host: string = DEFAULT_HOST,
-): Promise<ProviderModelConfig[]> {
-  const catalog = await getCachedCatalog(apiKey, host).catch(() => null);
+export function buildLiveModels(catalog: CacheEntry | null): ProviderModelConfig[] {
+    if (!catalog || catalog.byUid.size === 0) {
+        return FALLBACK_MODELS;
+    }
 
-  if (!catalog || catalog.byUid.size === 0) {
-    return FALLBACK_MODELS;
-  }
+    const models: ProviderModelConfig[] = [];
+    for (const entry of catalog.byUid.values()) {
+        if (entry.disabled) continue;
+        if (!matchesWantedPrefix(entry.modelUid)) continue;
+        const meta = findMeta(entry.modelUid) ?? DEFAULT_META;
+        models.push(makeModel(entry.modelUid, entry.label || entry.modelUid, meta));
+    }
 
-  return [...catalog.byUid.values()]
-    .filter((entry) => !entry.disabled)
-    .map((entry) => {
-      const override = MODEL_OVERRIDES.get(entry.modelUid);
-      return {
-        id: entry.modelUid,
-        name: entry.label || entry.modelUid,
-        reasoning: override?.reasoning ?? DEFAULT_REASONING,
-        input: override?.input ?? DEFAULT_INPUT,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: override?.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-        maxTokens: override?.maxTokens ?? DEFAULT_MAX_TOKENS,
-      };
-    });
+    if (models.length === 0) {
+        return FALLBACK_MODELS;
+    }
+
+    return models;
 }
+
+export { DEFAULT_HOST };