@edge-sky/dsh-oauth-adapter 0.1.2-beta.1 → 0.1.2-dev.2

package/lib/model-discovery.js

@@ -0,0 +1,147 @@
+import { modelText } from './model-types.js';
+export class ModelOperationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function invalid() { throw new ModelOperationError('invalid-catalog', 'The provider returned an invalid model catalog.'); }
+/** Read a bounded page; errors never include response bodies or token-bearing URLs. */
+async function readPage(url, headers, options) {
+    const response = await (options.fetch ?? globalThis.fetch)(url, { headers, signal: options.signal, redirect: 'error' });
+    if (!response.ok) {
+        await response.body?.cancel();
+        throw new ModelOperationError(response.status === 401 || response.status === 403 ? 'discovery-auth' : response.status === 404 || response.status === 405 ? 'discovery-unsupported' : 'discovery-failed', `Model discovery returned HTTP ${response.status}.`);
+    }
+    if (!response.body)
+        invalid();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            size += part.value.byteLength;
+            if (size > options.maxBytes)
+                throw new ModelOperationError('catalog-too-large', 'The model catalog exceeds the configured response limit.');
+            chunks.push(part.value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        invalid();
+    }
+    return record(value) ?? invalid();
+}
+/** Fetch complete account-visible results; never substitute the public OpenRouter catalog. */
+export async function discoverAccountModels(provider, resolved, options) {
+    const headers = new Headers(resolved.auth.headers);
+    headers.set('accept', 'application/json');
+    if (resolved.auth.apiKey)
+        headers.set('authorization', `Bearer ${resolved.auth.apiKey}`);
+    let url;
+    switch (provider) {
+        case 'github-copilot':
+            url = new URL(`${(resolved.auth.baseUrl ?? 'https://api.individual.githubcopilot.com').replace(/\/+$/, '')}/models`);
+            headers.set('editor-version', 'vscode/1.107.0');
+            headers.set('editor-plugin-version', 'copilot-chat/0.35.0');
+            headers.set('copilot-integration-id', 'vscode-chat');
+            headers.set('user-agent', 'GitHubCopilotChat/0.35.0');
+            headers.set('x-github-api-version', '2026-06-01');
+            break;
+        case 'openai-codex':
+            if (!resolved.accountId)
+                throw new ModelOperationError('discovery-auth', 'The Codex credential has no account ID; reconnect this account.');
+            url = new URL('https://chatgpt.com/backend-api/codex/models');
+            url.searchParams.set('client_version', options.codexClientVersion);
+            headers.set('chatgpt-account-id', resolved.accountId);
+            headers.set('originator', 'pi');
+            break;
+        case 'anthropic':
+            url = new URL('https://api.anthropic.com/v1/models?limit=1000');
+            headers.set('anthropic-version', '2023-06-01');
+            headers.set('anthropic-beta', 'oauth-2025-04-20');
+            break;
+        case 'kimi-coding':
+            url = new URL('https://api.kimi.com/coding/v1/models');
+            break;
+        case 'openrouter':
+            url = new URL('https://openrouter.ai/api/v1/models/user?limit=500&offset=0');
+            break;
+        case 'xai':
+            url = new URL('https://api.x.ai/v1/models');
+            break;
+    }
+    const results = new Map();
+    const cursors = new Set();
+    for (let page = 0; page < options.maxPages; page += 1) {
+        options.signal.throwIfAborted();
+        const body = await readPage(url, headers, options);
+        const data = provider === 'openai-codex' ? body.models : body.data;
+        if (!Array.isArray(data))
+            invalid();
+        for (const raw of data) {
+            const item = record(raw) ?? invalid();
+            const id = provider === 'openai-codex' ? item.slug : item.id;
+            if (!modelText(id))
+                invalid();
+            if (provider === 'github-copilot') {
+                const capabilities = record(item.capabilities);
+                if (record(capabilities?.supports)?.tool_calls === false)
+                    continue;
+                if (item.model_picker_enabled !== true || record(item.policy)?.state === 'disabled')
+                    continue;
+            }
+            if (provider === 'openai-codex' && item.visibility !== 'list')
+                continue;
+            const name = item.display_name ?? item.name;
+            if (name !== undefined && !modelText(name))
+                invalid();
+            results.set(id, { id, ...(name === undefined ? {} : { name }) });
+        }
+        if (provider === 'openrouter') {
+            if (body.total_count !== undefined && (!Number.isSafeInteger(body.total_count) || body.total_count < 0))
+                invalid();
+            const consumed = Number(url.searchParams.get('offset')) + data.length;
+            const more = body.total_count !== undefined ? consumed < body.total_count : data.length === 500;
+            if (more) {
+                if (data.length === 0 || cursors.has(JSON.stringify(data)))
+                    invalid();
+                cursors.add(JSON.stringify(data));
+                url = new URL(url);
+                url.searchParams.set('offset', String(consumed));
+                continue;
+            }
+            return [...results.values()];
+        }
+        if (body.has_more === undefined || body.has_more === false)
+            return [...results.values()];
+        if (provider !== 'anthropic')
+            invalid();
+        if (body.has_more !== true || !modelText(body.last_id) || cursors.has(body.last_id))
+            invalid();
+        cursors.add(body.last_id);
+        url = new URL(url);
+        url.searchParams.set('after_id', body.last_id);
+    }
+    throw new ModelOperationError('catalog-too-large', 'The model catalog exceeds the configured page limit.');
+}
+//# sourceMappingURL=model-discovery.js.map

package/lib/model-service.d.ts

@@ -0,0 +1,64 @@
+/** Persistent OAuth model management and reversible ownership of existing provider routes. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { CredentialProvider } from '@deepseek-ai/dsh-credentials';
+import type { SettingsProvider } from '@deepseek-ai/dsh-settings';
+import type LlmRuntime from '@deepseek-ai/dsh-llm';
+import { type ProviderId } from './protocol.js';
+import { type ModelPage, type ManualModel } from './model-types.js';
+export interface ModelServiceOptions {
+    timeoutMs: number;
+    maxResponseBytes: number;
+    maxPages: number;
+    codexClientVersion: string;
+}
+export type ModelContext = Context & {
+    settings: SettingsProvider;
+    credentials: CredentialProvider;
+    llm: LlmRuntime;
+};
+export declare class OAuthModelService {
+    private readonly ctx;
+    private readonly options;
+    private readonly changed;
+    private profiles;
+    private handle;
+    private readonly queues;
+    private readonly syncs;
+    private readonly controllers;
+    private readonly generations;
+    private readonly loggingIn;
+    private readonly errors;
+    private readonly disposers;
+    private closed;
+    private readonly stop;
+    private readonly signedOut;
+    private readonly adapter;
+    readonly ready: Promise<void>;
+    constructor(ctx: ModelContext, options: ModelServiceOptions, changed: (provider: ProviderId) => void);
+    private state;
+    revision(): number;
+    isManaged(provider: ProviderId): boolean;
+    private checkRevision;
+    private checkOpen;
+    private save;
+    private report;
+    private enqueue;
+    private initialize;
+    private legacy;
+    private connected;
+    private publish;
+    private reconcile;
+    /** Wait on the actual route registry; settings persistence alone does not imply adapter release. */
+    private releaseLegacy;
+    private ensureManaged;
+    page(provider: ProviderId, offset: number): Promise<ModelPage>;
+    migrate(provider: ProviderId, revision: number): Promise<void>;
+    saveManual(provider: ProviderId, model: ManualModel, revision: number): Promise<void>;
+    deleteManual(provider: ProviderId, id: string, revision: number): Promise<void>;
+    sync(provider: ProviderId, revision: number): Promise<void>;
+    loginStarted(provider: ProviderId): void;
+    loginFinished(provider: ProviderId, authorized: boolean): Promise<void>;
+    forget(provider: ProviderId): Promise<void>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=model-service.d.ts.map

package/lib/model-service.js

@@ -0,0 +1,371 @@
+import z from '@deepseek-ai/schemastery';
+import { createModels } from '@earendil-works/pi-ai';
+import { SettingsConflictError } from '@deepseek-ai/dsh-settings';
+import { resolveImageAttachmentAccess } from '@deepseek-ai/dsh-llm';
+import { PiAiAdapter, recordKeyFor } from '@deepseek-ai/dsh-llm-pi-ai';
+import { PROVIDERS } from './protocol.js';
+import { MODEL_PAGE_SIZE, MODEL_PROTOCOLS, validManual } from './model-types.js';
+import { accountIdentity, credentialBridge, fromRecord } from './model-auth.js';
+import { materialize, providerFactories, validateModelStore } from './model-catalog.js';
+import { discoverAccountModels, ModelOperationError } from './model-discovery.js';
+const NS = 'oauth-models';
+const LEGACY_NS = 'llm-pi-ai';
+const Schema = z.object({ version: z.const(1).default(1), providers: z.dict(z.any()).default({}) });
+function object(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
+function failure(code, message) { throw new ModelOperationError(code, message); }
+export class OAuthModelService {
+    ctx;
+    options;
+    changed;
+    profiles = new Map();
+    handle;
+    queues = new Map();
+    syncs = new Map();
+    controllers = new Map();
+    generations = new Map();
+    loggingIn = new Set();
+    errors = new Map();
+    disposers = [];
+    closed = false;
+    stop = new AbortController();
+    signedOut = new Set();
+    adapter;
+    ready;
+    constructor(ctx, options, changed) {
+        this.ctx = ctx;
+        this.options = options;
+        this.changed = changed;
+        const scope = ctx.settings.register(NS, Schema, { base: { version: 1, providers: {} }, validate: value => { validateModelStore(value); } });
+        this.adapter = new PiAiAdapter({
+            profiles: () => this.profiles,
+            resolveApiKey: async () => undefined,
+            auth: { credentials: credentialBridge(ctx.credentials, provider => { if (this.closed)
+                    failure('disposed', 'OAuth models have stopped.'); if (this.signedOut.has(provider))
+                    failure('not-connected', 'This account was disconnected.'); if (this.loggingIn.has(provider))
+                    failure('busy', 'Account reconnection is in progress.'); }), authContext: { env: async () => undefined, fileExists: async () => false } },
+            resolveAttachments: () => ctx.get('attachments'),
+            resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, hostPath => ctx.get('fs')?.processPathFromHostPath(hostPath), ref),
+        });
+        this.ready = this.initialize();
+        this.disposers.push(scope.watch(() => {
+            if (this.closed)
+                return;
+            for (const p of PROVIDERS)
+                void this.enqueue(p.id, async () => { await this.reconcile(p.id); }).catch(error => this.report(p.id, error));
+        }));
+        this.disposers.push(ctx.on('credentials/record-updated', key => {
+            const provider = PROVIDERS.find(p => p.key === key)?.id;
+            if (!provider || this.closed || this.loggingIn.has(provider))
+                return;
+            void this.enqueue(provider, async () => { await this.reconcile(provider); }).catch(error => this.report(provider, error));
+        }));
+    }
+    state() { return validateModelStore(this.ctx.settings.get(NS)); }
+    revision() { return this.ctx.settings.describe().find(s => s.ns === NS)?.revision ?? 0; }
+    isManaged(provider) { return this.profiles.has(provider); }
+    checkRevision(revision) { if (revision !== this.revision())
+        failure('settings-conflict', 'Models changed in another operation. Refresh and retry.'); }
+    checkOpen() { if (this.closed)
+        failure('disposed', 'OAuth models have stopped.'); }
+    async save(provider, state, revision = this.revision()) {
+        this.checkOpen();
+        materialize(provider, state);
+        try {
+            await this.ctx.settings.mutate(NS, [{ op: 'set', path: ['providers', provider], value: state }], revision);
+        }
+        catch (error) {
+            if (error instanceof SettingsConflictError)
+                failure('settings-conflict', 'Models changed in another operation. Refresh and retry.');
+            throw error;
+        }
+    }
+    report(provider, error) {
+        this.errors.set(provider, error instanceof ModelOperationError ? { code: error.code, message: error.message } : { code: 'operation-failed', message: 'Model operation failed. The previous configuration was retained.' });
+        this.changed(provider);
+    }
+    enqueue(provider, action) {
+        if (this.closed)
+            return Promise.reject(new ModelOperationError('disposed', 'OAuth models have stopped.'));
+        const previous = this.queues.get(provider) ?? Promise.resolve();
+        const task = previous.catch(() => { }).then(() => { this.checkOpen(); return action(); });
+        this.queues.set(provider, task);
+        void task.finally(() => { if (this.queues.get(provider) === task)
+            this.queues.delete(provider); }).catch(() => { });
+        return task;
+    }
+    async initialize() {
+        for (const p of PROVIDERS) {
+            try {
+                await this.enqueue(p.id, async () => { await this.ensureManaged(p.id, false); });
+            }
+            catch (error) {
+                this.report(p.id, error);
+            }
+        }
+    }
+    legacy(provider) {
+        const descriptor = this.ctx.settings.describe().find(s => s.ns === LEGACY_NS);
+        if (!descriptor)
+            failure('model-host', 'The DSH pi-ai settings namespace is unavailable.');
+        const profile = object(object(descriptor.user)?.providers)?.[provider];
+        const base = object(object(descriptor.base)?.providers)?.[provider];
+        const value = object(profile);
+        const label = PROVIDERS.find(p => p.id === provider).modelGroupLabel;
+        return { profile: value, revision: descriptor.revision,
+            custom: value !== undefined && !(Object.keys(value).length === 1 && value.displayName === label),
+            blocked: base !== undefined || (value !== undefined && value.apiKeyEnv !== undefined) };
+    }
+    async connected(provider) { return !this.signedOut.has(provider) && fromRecord(await this.ctx.credentials.readRecord(recordKeyFor(provider)))?.type === 'oauth'; }
+    async publish(provider, state) {
+        this.checkOpen();
+        const next = new Map(this.profiles);
+        if (state && await this.connected(provider))
+            next.set(provider, materialize(provider, state).profile);
+        else
+            next.delete(provider);
+        this.checkOpen();
+        const old = this.profiles;
+        this.profiles = next;
+        try {
+            if (this.handle)
+                this.handle.replace([...next.keys()]);
+            else if (next.size)
+                this.handle = this.ctx.llm.registerAdapter([...next.keys()], this.adapter);
+        }
+        catch (error) {
+            this.profiles = old;
+            throw error;
+        }
+        this.changed(provider);
+    }
+    async reconcile(provider) {
+        if (this.loggingIn.has(provider))
+            return;
+        const state = this.state().providers[provider];
+        await this.publish(provider, state?.phase === 'managed' ? state : undefined);
+    }
+    /** Wait on the actual route registry; settings persistence alone does not imply adapter release. */
+    async releaseLegacy(provider, revision) {
+        const signal = AbortSignal.any([this.stop.signal, AbortSignal.timeout(this.options.timeoutMs)]);
+        let wake;
+        const dispose = this.ctx.on('llm/adapters-updated', () => { wake?.(); });
+        try {
+            await this.ctx.settings.mutate(LEGACY_NS, [{ op: 'unset', path: ['providers', provider] }], revision);
+            while (this.ctx.llm.listProviders().some(p => p.id === provider)) {
+                signal.throwIfAborted();
+                await new Promise((resolve, reject) => {
+                    const abort = () => { cleanup(); reject(new ModelOperationError('route-conflict', 'The previous model adapter did not release this provider.')); };
+                    const cleanup = () => { signal.removeEventListener('abort', abort); wake = undefined; };
+                    wake = () => { cleanup(); resolve(); };
+                    signal.addEventListener('abort', abort, { once: true });
+                    if (signal.aborted)
+                        abort();
+                    else if (!this.ctx.llm.listProviders().some(p => p.id === provider))
+                        wake();
+                });
+            }
+        }
+        finally {
+            dispose();
+        }
+    }
+    async ensureManaged(provider, approve) {
+        if (!await this.connected(provider))
+            return;
+        let state = this.state().providers[provider];
+        if (state?.phase === 'managed') {
+            await this.publish(provider, state);
+            return;
+        }
+        const legacy = this.legacy(provider);
+        if (legacy.blocked)
+            failure('route-conflict', 'This provider has an API-key reference or a composition-owned profile; it was not changed.');
+        if (!state && legacy.custom && !approve)
+            failure('migration-required', 'Review and migrate the existing custom OAuth configuration before managing models.');
+        if (!state) {
+            state = { phase: 'pending', legacy: legacy.profile ?? { displayName: PROVIDERS.find(p => p.id === provider).modelGroupLabel }, manual: [], restoredFromLegacy: legacy.profile !== undefined };
+            const choices = MODEL_PROTOCOLS[provider];
+            if (state.legacy.api && !choices.includes(state.legacy.api))
+                failure('route-conflict', 'The existing protocol is not supported by this OAuth provider.');
+            state.manual = (state.legacy.models ?? []).map(model => {
+                const api = state.legacy.api ?? providerFactories[provider]().getModels().find(m => m.id === model.id)?.api ?? (choices.length === 1 ? choices[0] : undefined);
+                if (!api)
+                    failure('model-protocol', `Existing model ${model.id} needs an explicit protocol.`);
+                return { id: model.id, ...(model.name ? { name: model.name } : {}), ...(choices.length > 1 ? { api: api } : {}) };
+            });
+            await this.save(provider, state);
+        }
+        try {
+            if (legacy.profile)
+                await this.releaseLegacy(provider, legacy.revision);
+            else if (this.ctx.llm.listProviders().some(p => p.id === provider) && !this.profiles.has(provider))
+                failure('route-conflict', 'Another adapter owns this provider; it was not changed.');
+            const managed = { ...state, phase: 'managed' };
+            await this.publish(provider, managed);
+            await this.save(provider, managed);
+            this.errors.delete(provider);
+        }
+        catch (error) {
+            await this.publish(provider, undefined);
+            // Restore only if the source is still absent. Never overwrite a concurrent profile edit.
+            const source = this.legacy(provider);
+            if (!source.profile && state.restoredFromLegacy)
+                await this.ctx.settings.mutate(LEGACY_NS, [{ op: 'set', path: ['providers', provider], value: state.legacy }], source.revision);
+            throw error;
+        }
+    }
+    async page(provider, offset) {
+        await this.ready;
+        const state = this.state().providers[provider];
+        const fallback = { phase: 'pending', legacy: this.legacy(provider).profile ?? {}, manual: [] };
+        const rows = materialize(provider, state ?? fallback).rows;
+        const legacy = this.legacy(provider);
+        offset = Math.min(offset, Math.max(0, Math.floor((rows.length - 1) / MODEL_PAGE_SIZE) * MODEL_PAGE_SIZE));
+        return {
+            provider, revision: this.revision(), offset, total: rows.length, rows: rows.slice(offset, offset + MODEL_PAGE_SIZE),
+            source: state?.discovered ? 'account' : 'catalog',
+            counts: { matched: rows.filter(r => r.source === 'matched' || r.source === 'catalog').length, pending: rows.filter(r => r.source === 'pending').length, manual: rows.filter(r => r.source === 'manual').length },
+            connected: await this.connected(provider), writable: this.ctx.settings.writable,
+            managed: this.isManaged(provider), busy: this.syncs.has(provider),
+            ...(state?.syncedAt === undefined ? {} : { syncedAt: state.syncedAt }),
+            ...(this.errors.has(provider) ? { error: this.errors.get(provider).message, errorCode: this.errors.get(provider).code } : {}),
+            ...((state?.phase === 'pending' || !state && legacy.custom) && !legacy.blocked ? { migration: { fields: Object.keys(state?.legacy ?? legacy.profile ?? {}), models: (state?.legacy ?? legacy.profile)?.models?.length ?? 0 } } : {}),
+        };
+    }
+    async migrate(provider, revision) {
+        await this.ready;
+        return this.enqueue(provider, async () => { this.checkRevision(revision); await this.ensureManaged(provider, true); });
+    }
+    async saveManual(provider, model, revision) {
+        if (!validManual(provider, model))
+            failure('invalid-model', 'Model fields or protocol are invalid.');
+        await this.ready;
+        return this.enqueue(provider, async () => {
+            this.checkRevision(revision);
+            await this.ensureManaged(provider, false);
+            const state = this.state().providers[provider];
+            if (!state || !await this.connected(provider))
+                failure('not-connected', 'Connect this provider before editing models.');
+            const next = { ...state, manual: [...state.manual.filter(m => m.id !== model.id), model] };
+            await this.save(provider, next);
+            await this.publish(provider, next);
+        });
+    }
+    async deleteManual(provider, id, revision) {
+        await this.ready;
+        return this.enqueue(provider, async () => {
+            this.checkRevision(revision);
+            const state = this.state().providers[provider];
+            if (!state)
+                failure('not-connected', 'This provider has no managed models.');
+            const next = { ...state, manual: state.manual.filter(m => m.id !== id) };
+            await this.save(provider, next);
+            await this.publish(provider, next);
+        });
+    }
+    async sync(provider, revision) {
+        await this.ready;
+        const running = this.syncs.get(provider);
+        if (running)
+            return running;
+        const generation = this.generations.get(provider) ?? 0;
+        const controller = new AbortController();
+        this.controllers.set(provider, controller);
+        const task = this.enqueue(provider, async () => {
+            this.checkRevision(revision);
+            await this.ensureManaged(provider, false);
+            const state = this.state().providers[provider];
+            if (!state || !await this.connected(provider))
+                failure('not-connected', 'Connect this provider before synchronizing models.');
+            const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(this.options.timeoutMs)]);
+            const check = () => { this.checkOpen(); signal.throwIfAborted(); if ((this.generations.get(provider) ?? 0) !== generation)
+                failure('cancelled', 'The account changed during synchronization.'); };
+            const collection = createModels({ credentials: credentialBridge(this.ctx.credentials, check), authContext: { env: async () => undefined, fileExists: async () => false } });
+            collection.setProvider(providerFactories[provider]());
+            const resolved = await collection.getAuth(provider, { signal });
+            check();
+            if (!resolved)
+                failure('not-connected', 'The provider has no usable OAuth credential.');
+            const credential = fromRecord(await this.ctx.credentials.readRecord(recordKeyFor(provider)));
+            const accountId = credential?.type === 'oauth' && typeof credential.accountId === 'string' ? credential.accountId : undefined;
+            const discovered = await discoverAccountModels(provider, { auth: resolved.auth, ...(accountId ? { accountId } : {}) }, {
+                signal, maxBytes: this.options.maxResponseBytes, maxPages: this.options.maxPages, codexClientVersion: this.options.codexClientVersion,
+            });
+            check();
+            const next = { ...state, discovered, syncedAt: new Date().toISOString() };
+            const identity = accountIdentity(provider, credential);
+            if (identity)
+                next.account = identity;
+            const expected = this.revision();
+            // External edits while a network request was pending must not be overwritten.
+            if (JSON.stringify(this.state().providers[provider]) !== JSON.stringify(state))
+                failure('settings-conflict', 'Models changed during synchronization. Refresh and retry.');
+            await this.save(provider, next, expected);
+            check();
+            await this.publish(provider, next);
+            this.errors.delete(provider);
+        }).catch(error => {
+            const failure = error instanceof ModelOperationError ? error : error instanceof Error && error.name === 'TimeoutError' ? new ModelOperationError('discovery-timeout', 'Model discovery timed out; the previous list was retained.') : controller.signal.aborted ? new ModelOperationError('cancelled', 'Model synchronization was cancelled.') : new ModelOperationError('discovery-failed', 'Model discovery failed; the previous list was retained.');
+            this.report(provider, failure);
+            throw failure;
+        }).finally(() => {
+            if (this.controllers.get(provider) === controller)
+                this.controllers.delete(provider);
+            this.syncs.delete(provider);
+            if (!this.closed)
+                this.changed(provider);
+        });
+        this.syncs.set(provider, task);
+        this.changed(provider);
+        return task;
+    }
+    loginStarted(provider) {
+        this.loggingIn.add(provider);
+        this.generations.set(provider, (this.generations.get(provider) ?? 0) + 1);
+        this.controllers.get(provider)?.abort();
+    }
+    async loginFinished(provider, authorized) {
+        if (authorized)
+            this.signedOut.delete(provider);
+        this.loggingIn.delete(provider);
+        await this.ready;
+        await this.enqueue(provider, async () => {
+            if (authorized) {
+                const state = this.state().providers[provider];
+                const identity = accountIdentity(provider, fromRecord(await this.ctx.credentials.readRecord(recordKeyFor(provider))));
+                if (state && (!identity || identity !== state.account)) {
+                    const { discovered: _discovered, syncedAt: _time, account: _account, ...rest } = state;
+                    await this.save(provider, { ...rest, ...(identity ? { account: identity } : {}) });
+                }
+                await this.ensureManaged(provider, false);
+            }
+            else
+                await this.reconcile(provider);
+        });
+        if (authorized)
+            await this.sync(provider, this.revision());
+    }
+    async forget(provider) {
+        this.signedOut.add(provider);
+        this.generations.set(provider, (this.generations.get(provider) ?? 0) + 1);
+        this.controllers.get(provider)?.abort();
+        await this.ready;
+        await this.enqueue(provider, async () => {
+            await this.ctx.credentials.deleteRecord(recordKeyFor(provider));
+            await this.publish(provider, undefined);
+            this.errors.delete(provider);
+        });
+    }
+    async dispose() {
+        this.closed = true;
+        this.stop.abort();
+        for (const dispose of this.disposers)
+            dispose();
+        for (const controller of this.controllers.values())
+            controller.abort();
+        await Promise.allSettled([...this.queues.values()]);
+        this.handle?.();
+        this.profiles = new Map();
+    }
+}
+//# sourceMappingURL=model-service.js.map

package/lib/model-types.d.ts

@@ -0,0 +1,92 @@
+/** Model-management messages shared by the browser and Host. No credentials travel here. */
+import type { ProviderId } from './protocol.js';
+export declare const MODEL_PAGE_SIZE = 10;
+export declare const MODEL_PROTOCOLS: {
+    readonly 'github-copilot': readonly ["openai-completions", "openai-responses", "anthropic-messages"];
+    readonly openrouter: readonly ["openai-completions", "anthropic-messages"];
+    readonly 'openai-codex': readonly ["openai-codex-responses"];
+    readonly xai: readonly ["openai-responses"];
+    readonly anthropic: readonly ["anthropic-messages"];
+    readonly 'kimi-coding': readonly ["anthropic-messages"];
+};
+export type ModelProtocol = (typeof MODEL_PROTOCOLS)[ProviderId][number];
+export interface ManualModel {
+    id: string;
+    name?: string;
+    api?: ModelProtocol;
+}
+export interface DiscoveredModel {
+    id: string;
+    name?: string;
+}
+export interface ModelRow {
+    id: string;
+    name: string;
+    source: 'catalog' | 'matched' | 'pending' | 'manual';
+    api?: string;
+}
+export interface ModelPage {
+    provider: ProviderId;
+    revision: number;
+    offset: number;
+    total: number;
+    rows: ModelRow[];
+    source: 'catalog' | 'account';
+    counts: {
+        matched: number;
+        pending: number;
+        manual: number;
+    };
+    connected: boolean;
+    writable: boolean;
+    managed: boolean;
+    busy: boolean;
+    syncedAt?: string;
+    error?: string;
+    errorCode?: string;
+    migration?: {
+        fields: string[];
+        models: number;
+    };
+}
+export type ModelCommand = {
+    type: 'models-list';
+    requestId: string;
+    provider: ProviderId;
+    offset: number;
+} | {
+    type: 'models-sync' | 'models-migrate';
+    requestId: string;
+    provider: ProviderId;
+    revision: number;
+} | {
+    type: 'models-save';
+    requestId: string;
+    provider: ProviderId;
+    revision: number;
+    model: ManualModel;
+} | {
+    type: 'models-delete';
+    requestId: string;
+    provider: ProviderId;
+    revision: number;
+    id: string;
+};
+export type ModelMessage = {
+    type: 'models-page';
+    requestId: string;
+    page: ModelPage;
+} | {
+    type: 'models-changed';
+    provider: ProviderId;
+} | {
+    type: 'models-error';
+    requestId: string;
+    provider: ProviderId;
+    code: string;
+    message: string;
+};
+export declare function modelText(value: unknown): value is string;
+/** Validate at the wire and durable-data boundaries; fixed-protocol routes accept no override. */
+export declare function validManual(provider: ProviderId, value: unknown): value is ManualModel;
+//# sourceMappingURL=model-types.d.ts.map