@code-yeongyu/senpi-ai 2026.8.12 → 2026.8.13

package/dist/models.js

@@ -3,6 +3,7 @@ import { defaultProviderAuthContext as defaultAuthContext } from "./auth/context
 import { InMemoryCredentialStore } from "./auth/credential-store.js";
 import { ModelsError, resolveProviderAuth } from "./auth/resolve.js";
 import { InMemoryModelsStore } from "./models-store.js";
+import { operationSignal, raceWithAbortSignal } from "./utils/abort.js";
 export { ModelsError } from "./auth/resolve.js";
 function mergeHeaders(base, override) {
     if (!base && !override)
@@ -21,17 +22,25 @@ function mergeHeaders(base, override) {
 class ModelsImpl {
     constructor(options) {
         this.providers = new Map();
+        this.refreshGenerations = new Map();
+        this.refreshControllers = new Map();
+        this.publicationChains = new Map();
         this.credentials = options?.credentials ?? new InMemoryCredentialStore();
         this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore();
         this.authContext = options?.authContext ?? defaultAuthContext();
     }
     setProvider(provider) {
+        this.supersedeProviderRefresh(provider.id);
         this.providers.set(provider.id, provider);
     }
     deleteProvider(id) {
+        this.supersedeProviderRefresh(id);
         this.providers.delete(id);
     }
     clearProviders() {
+        for (const id of new Set([...this.providers.keys(), ...this.refreshControllers.keys()])) {
+            this.supersedeProviderRefresh(id);
+        }
         this.providers.clear();
     }
     getProviders() {
@@ -66,87 +75,148 @@ class ModelsImpl {
     getModel(provider, id) {
         return this.getModels(provider).find((model) => model.id === id);
     }
+    supersedeProviderRefresh(providerId) {
+        const generation = (this.refreshGenerations.get(providerId) ?? 0) + 1;
+        this.refreshGenerations.set(providerId, generation);
+        const previous = this.refreshControllers.get(providerId);
+        if (previous) {
+            this.refreshControllers.delete(providerId);
+            previous.abort();
+        }
+        return generation;
+    }
+    beginProviderRefresh(providerId) {
+        const generation = this.supersedeProviderRefresh(providerId);
+        const controller = new AbortController();
+        this.refreshControllers.set(providerId, controller);
+        return { generation, controller };
+    }
+    publishProviderModels(providerId, generation, signal, publication) {
+        const previous = this.publicationChains.get(providerId) ?? Promise.resolve();
+        const queued = (async () => {
+            await previous.catch(() => { });
+            if (signal.aborted || this.refreshGenerations.get(providerId) !== generation)
+                return false;
+            if (publication.persist === null) {
+                await this.modelsStore.delete(providerId, { signal });
+            }
+            else if (publication.persist !== undefined) {
+                await this.modelsStore.write(providerId, structuredClone(publication.persist), { signal });
+            }
+            if (signal.aborted || this.refreshGenerations.get(providerId) !== generation)
+                return false;
+            publication.update?.();
+            return true;
+        })();
+        const tail = queued.catch(() => { });
+        this.publicationChains.set(providerId, tail);
+        void tail.then(() => {
+            if (this.publicationChains.get(providerId) === tail)
+                this.publicationChains.delete(providerId);
+        });
+        return raceWithAbortSignal(queued, signal);
+    }
+    async runProviderRefreshPhase(provider, credential, allowNetwork, force, generation, signal) {
+        const stored = await this.modelsStore.read(provider.id, { signal });
+        await provider.refreshModels({
+            credential,
+            stored: stored ? structuredClone(stored) : undefined,
+            publish: (publication) => this.publishProviderModels(provider.id, generation, signal, publication),
+            allowNetwork,
+            force: allowNetwork ? force : undefined,
+            signal,
+        });
+    }
     async refresh(options = {}) {
         const allowNetwork = options.allowNetwork ?? true;
+        const callerSignal = operationSignal(options.signal);
         const errors = new Map();
-        const refreshable = Array.from(this.providers.values()).filter((provider) => provider.refreshModels !== undefined);
-        await Promise.all(refreshable.map(async (provider) => {
-            if (options.signal?.aborted)
-                return;
-            const store = {
-                read: () => this.modelsStore.read(provider.id),
-                write: (entry) => this.modelsStore.write(provider.id, entry),
-                delete: () => this.modelsStore.delete(provider.id),
-            };
-            let stored;
-            try {
-                stored = await this.readCredential(provider.id);
-                const credential = await this.resolveRefreshCredential(provider, stored, allowNetwork, options.signal);
+        if (callerSignal.aborted)
+            return { aborted: true, errors };
+        const selected = options.providers ? new Set(options.providers) : undefined;
+        const refreshable = Array.from(this.providers.values()).filter((provider) => provider.refreshModels !== undefined && (!selected || selected.has(provider.id)));
+        const refresh = Promise.all(refreshable.map(async (provider) => {
+            const { generation, controller } = this.beginProviderRefresh(provider.id);
+            const signal = AbortSignal.any([callerSignal, controller.signal]);
+            const operation = (async () => {
+                let storedCredential;
+                let credentialError;
+                try {
+                    storedCredential = await this.readCredential(provider.id, signal);
+                }
+                catch (error) {
+                    credentialError = error;
+                }
+                // Restore cached provider state before auth resolution or network access.
+                await this.runProviderRefreshPhase(provider, storedCredential, false, undefined, generation, signal);
+                if (credentialError !== undefined)
+                    throw credentialError;
+                if (!allowNetwork || signal.aborted)
+                    return;
+                const credential = await this.resolveRefreshCredential(provider, storedCredential, signal);
                 if (!credential)
                     return;
-                await provider.refreshModels({
-                    credential,
-                    store,
-                    allowNetwork,
-                    force: options.force,
-                    signal: options.signal,
-                });
+                await this.runProviderRefreshPhase(provider, credential, true, options.force, generation, signal);
+            })();
+            try {
+                await raceWithAbortSignal(operation, signal);
             }
             catch (error) {
-                if (!options.signal?.aborted) {
+                if (!signal.aborted) {
                     errors.set(provider.id, error instanceof Error
                         ? error
                         : new ModelsError("model_source", `Model refresh failed for ${provider.id}`, { cause: error }));
                 }
-                try {
-                    await provider.refreshModels({
-                        credential: stored,
-                        store,
-                        allowNetwork: false,
-                        signal: options.signal,
-                    });
-                }
-                catch {
-                    // Preserve the original auth/network error; cache restoration is best-effort here.
+            }
+            finally {
+                if (this.refreshControllers.get(provider.id) === controller) {
+                    this.refreshControllers.delete(provider.id);
                 }
             }
         }));
-        return { aborted: options.signal?.aborted ?? false, errors };
+        try {
+            await raceWithAbortSignal(refresh, callerSignal);
+        }
+        catch (error) {
+            if (!callerSignal.aborted)
+                throw error;
+        }
+        return { aborted: callerSignal.aborted, errors: new Map(errors) };
     }
-    async resolveRefreshCredential(provider, stored, allowNetwork, signal) {
+    async resolveRefreshCredential(provider, stored, signal) {
         if (stored?.type === "oauth") {
             const oauth = provider.auth.oauth;
             if (!oauth)
                 return undefined;
-            if (!allowNetwork || Date.now() < stored.expires)
+            if (Date.now() < stored.expires)
                 return stored;
-            if (signal?.aborted)
+            if (signal.aborted)
                 return undefined;
             const post = await this.credentials.modify(provider.id, async (current) => {
                 if (current?.type !== "oauth" || Date.now() < current.expires)
                     return undefined;
                 return oauth.refresh(current, signal);
-            });
+            }, { signal });
             return post?.type === "oauth" ? post : undefined;
         }
         const apiKey = provider.auth.apiKey;
         if (!apiKey)
             return undefined;
         const credential = stored?.type === "api_key" ? stored : undefined;
-        const result = await apiKey.resolve({ ctx: this.authContext, credential });
+        const result = await apiKey.resolve({ ctx: this.authContext, credential, signal });
         if (!result)
             return undefined;
         return { type: "api_key", key: result.auth.apiKey, env: result.env };
     }
-    async readCredential(providerId) {
+    async readCredential(providerId, signal) {
         try {
-            return await this.credentials.read(providerId);
+            return await this.credentials.read(providerId, { signal });
         }
         catch (error) {
             throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
         }
     }
-    async checkProviderAuth(provider, credential) {
+    async checkProviderAuth(provider, credential, signal) {
         const oauth = provider.auth.oauth;
         if (credential?.type === "oauth") {
             if (!oauth)
@@ -154,7 +224,7 @@ class ModelsImpl {
             if (!oauth.check)
                 return { source: "OAuth", type: "oauth" };
             try {
-                return await oauth.check({ ctx: this.authContext, credential });
+                return await oauth.check({ ctx: this.authContext, credential, signal });
             }
             catch (error) {
                 throw new ModelsError("auth", `OAuth auth check failed for provider ${provider.id}`, { cause: error });
@@ -167,6 +237,7 @@ class ModelsImpl {
                     const result = await apiKey.check({
                         ctx: this.authContext,
                         credential: credential?.type === "api_key" ? credential : undefined,
+                        signal,
                     });
                     if (result)
                         return result;
@@ -176,7 +247,7 @@ class ModelsImpl {
                 }
             }
             else {
-                const resolution = await resolveProviderAuth(provider, this.credentials, this.authContext);
+                const resolution = await resolveProviderAuth(provider, this.credentials, this.authContext, { signal });
                 if (resolution)
                     return { source: resolution.source, type: "api_key" };
             }
@@ -184,39 +255,50 @@ class ModelsImpl {
         if (!oauth?.check)
             return undefined;
         try {
-            return await oauth.check({ ctx: this.authContext });
+            return await oauth.check({ ctx: this.authContext, signal });
         }
         catch (error) {
             throw new ModelsError("auth", `OAuth auth check failed for provider ${provider.id}`, { cause: error });
         }
     }
-    async checkAuth(providerId) {
-        const provider = this.providers.get(providerId);
-        if (!provider)
-            return undefined;
-        return this.checkProviderAuth(provider, await this.readCredential(providerId));
-    }
-    async getAvailable(providerId) {
-        const providers = providerId
-            ? [this.providers.get(providerId)].filter((entry) => entry !== undefined)
-            : this.getProviders();
-        const checks = await Promise.all(providers.map(async (provider) => {
-            const credential = await this.readCredential(provider.id);
-            return { provider, credential, auth: await this.checkProviderAuth(provider, credential) };
-        }));
-        return checks.flatMap(({ provider, credential, auth }) => {
-            if (!auth)
-                return [];
-            const models = provider.getModels();
-            return provider.filterModels?.(models, credential) ?? models;
-        });
+    checkAuth(providerId, options) {
+        const signal = operationSignal(options?.signal);
+        const check = (async () => {
+            signal.throwIfAborted();
+            const provider = this.providers.get(providerId);
+            if (!provider)
+                return undefined;
+            return this.checkProviderAuth(provider, await this.readCredential(providerId, signal), signal);
+        })();
+        return raceWithAbortSignal(check, signal);
+    }
+    getAvailable(providerId, options) {
+        const signal = operationSignal(options?.signal);
+        const available = (async () => {
+            signal.throwIfAborted();
+            const providers = providerId
+                ? [this.providers.get(providerId)].filter((entry) => entry !== undefined)
+                : this.getProviders();
+            const checks = await Promise.all(providers.map(async (provider) => {
+                const credential = await this.readCredential(provider.id, signal);
+                return { provider, credential, auth: await this.checkProviderAuth(provider, credential, signal) };
+            }));
+            return checks.flatMap(({ provider, credential, auth }) => {
+                if (!auth)
+                    return [];
+                const models = provider.getModels();
+                return provider.filterModels?.(models, credential) ?? models;
+            });
+        })();
+        return raceWithAbortSignal(available, signal);
     }
     async getAuth(providerOrModel, overrides) {
+        const signal = operationSignal(overrides?.signal);
         const providerId = typeof providerOrModel === "string" ? providerOrModel : providerOrModel.provider;
         const provider = this.providers.get(providerId);
         if (!provider)
             return undefined;
-        const result = await resolveProviderAuth(provider, this.credentials, this.authContext, overrides);
+        const result = await resolveProviderAuth(provider, this.credentials, this.authContext, { ...overrides, signal });
         if (!result || typeof providerOrModel === "string" || !providerOrModel.headers)
             return result;
         return {
@@ -228,6 +310,8 @@ class ModelsImpl {
         };
     }
     async login(providerId, type, interaction) {
+        const signal = operationSignal(interaction.signal);
+        signal.throwIfAborted();
         const provider = this.providers.get(providerId);
         if (!provider)
             throw new ModelsError("provider", `Unknown provider: ${providerId}`);
@@ -235,20 +319,52 @@ class ModelsImpl {
         if (!method?.login) {
             throw new ModelsError("auth", `${provider.name} does not support ${type} login`);
         }
-        const credential = await method.login(interaction);
+        const loginOperation = method.login({ ...interaction, signal });
+        const credential = await raceWithAbortSignal(loginOperation, signal);
+        let mutationStarted = false;
+        let markMutationStarted;
+        const started = new Promise((resolve) => {
+            markMutationStarted = resolve;
+        });
+        const mutation = this.credentials.modify(providerId, async () => {
+            mutationStarted = true;
+            markMutationStarted?.();
+            return credential;
+        }, { signal });
+        void mutation.catch(() => { });
         try {
-            await this.credentials.modify(providerId, async () => credential);
+            await new Promise((resolve, reject) => {
+                const onAbort = () => {
+                    if (!mutationStarted)
+                        reject(signal.reason);
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                void Promise.race([started, mutation]).then(() => {
+                    signal.removeEventListener("abort", onAbort);
+                    resolve();
+                }, (error) => {
+                    signal.removeEventListener("abort", onAbort);
+                    reject(error);
+                });
+                if (signal.aborted)
+                    onAbort();
+            });
+            await mutation;
         }
         catch (error) {
+            signal.throwIfAborted();
             throw new ModelsError("auth", `Credential store modify failed for ${providerId}`, { cause: error });
         }
         return credential;
     }
-    async logout(providerId) {
+    async logout(providerId, options) {
+        const signal = operationSignal(options?.signal);
+        signal.throwIfAborted();
         try {
-            await this.credentials.delete(providerId);
+            await this.credentials.delete(providerId, { signal });
         }
         catch (error) {
+            signal.throwIfAborted();
             throw new ModelsError("auth", `Credential store delete failed for ${providerId}`, { cause: error });
         }
     }
@@ -264,6 +380,7 @@ class ModelsImpl {
         const resolution = await this.getAuth(model, {
             apiKey: options?.apiKey,
             env: options?.env,
+            signal: options?.signal,
         });
         if (!resolution) {
             throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
@@ -300,6 +417,24 @@ class ModelsImpl {
     async completeSimple(model, context, options) {
         return this.streamSimple(model, context, options).result();
     }
+    async fetchDeferred(model, handle, options) {
+        return lazyStream(model, async () => {
+            const provider = this.requireProvider(model);
+            if (!provider.fetchDeferred) {
+                throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
+            }
+            const { requestModel, requestOptions } = await this.applyAuth(model, options);
+            return provider.fetchDeferred(requestModel, handle, requestOptions);
+        }).result();
+    }
+    async cancelDeferred(model, handle, options) {
+        const provider = this.requireProvider(model);
+        if (!provider.cancelDeferred) {
+            throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
+        }
+        const { requestModel, requestOptions } = await this.applyAuth(model, options);
+        await provider.cancelDeferred(requestModel, handle, requestOptions);
+    }
 }
 export function createModels(options) {
     return new ModelsImpl(options);
@@ -313,7 +448,6 @@ export function createModels(options) {
 export function createProvider(input) {
     const baselineModels = input.models;
     let dynamicModels = [];
-    let inflightRefresh;
     const fetchModels = input.fetchModels;
     const currentModels = () => {
         const merged = [...baselineModels];
@@ -338,7 +472,7 @@ export function createProvider(input) {
         }
         return run(streams);
     };
-    return {
+    const provider = {
         id: input.id,
         name: input.name ?? input.id,
         baseUrl: input.baseUrl,
@@ -346,34 +480,56 @@ export function createProvider(input) {
         auth: input.auth,
         getModels: currentModels,
         refreshModels: fetchModels
-            ? (context) => {
-                inflightRefresh ??= (async () => {
-                    try {
-                        const stored = await context.store.read();
-                        if (stored) {
-                            dynamicModels = stored.models
-                                .filter((model) => model.provider === input.id)
-                                .map((model) => model);
-                        }
-                        if (!context.allowNetwork || context.signal?.aborted)
-                            return;
-                        const refreshed = await fetchModels(context);
-                        if (context.signal?.aborted || refreshed.length === 0)
-                            return;
-                        dynamicModels = refreshed;
-                        await context.store.write({ models: refreshed, checkedAt: Date.now() });
+            ? async (context) => {
+                if (context.stored) {
+                    const restored = context.stored.models
+                        .filter((model) => model.provider === input.id)
+                        .map((model) => model);
+                    if (!(await context.publish({
+                        update: () => {
+                            dynamicModels = restored;
+                        },
+                    }))) {
+                        return;
                     }
-                    finally {
-                        inflightRefresh = undefined;
-                    }
-                })();
-                return inflightRefresh;
+                }
+                if (!context.allowNetwork || context.signal.aborted)
+                    return;
+                const refreshed = await fetchModels(context);
+                if (context.signal.aborted || refreshed.length === 0)
+                    return;
+                await context.publish({
+                    persist: { models: refreshed, checkedAt: Date.now() },
+                    update: () => {
+                        dynamicModels = refreshed;
+                    },
+                });
             }
             : undefined,
         filterModels: input.filterModels,
         stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
         streamSimple: (model, context, options) => dispatch(model, (streams) => streams.streamSimple(model, context, options)),
     };
+    const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== undefined);
+    if (streams.some((entry) => entry.fetchDeferred !== undefined)) {
+        provider.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+            const implementation = apiFor(model);
+            if (!implementation?.fetchDeferred) {
+                throw new ModelsError("provider", `Provider ${input.id} does not support deferred responses for "${model.api}"`);
+            }
+            return implementation.fetchDeferred(model, handle, options);
+        });
+    }
+    if (streams.some((entry) => entry.cancelDeferred !== undefined)) {
+        provider.cancelDeferred = async (model, handle, options) => {
+            const implementation = apiFor(model);
+            if (!implementation?.cancelDeferred) {
+                throw new ModelsError("provider", `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`);
+            }
+            await implementation.cancelDeferred(model, handle, options);
+        };
+    }
+    return provider;
 }
 /**
  * Runtime-checked narrowing for dynamically looked-up models: