@desplega.ai/agent-swarm 1.130.0 → 1.131.0

package/dist/{cli-w10fkrf1.js → cli-akdvwc9v.js}

@@ -42,11 +42,28 @@ function lazyStream(model, setup) {
   });
   return outer;
 }
-function lazyApi(load) {
-  return {
+function lazyApi(load, capabilities) {
+  const api = {
     stream: (model, context, options) => lazyStream(model, async () => (await load()).stream(model, context, options)),
     streamSimple: (model, context, options) => lazyStream(model, async () => (await load()).streamSimple(model, context, options))
   };
+  if (capabilities?.fetchDeferred) {
+    api.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+      const implementation = await load();
+      if (!implementation.fetchDeferred)
+        throw new Error("API does not support deferred responses");
+      return implementation.fetchDeferred(model, handle, options);
+    });
+  }
+  if (capabilities?.cancelDeferred) {
+    api.cancelDeferred = async (model, handle, options) => {
+      const implementation = await load();
+      if (!implementation.cancelDeferred)
+        throw new Error("API cannot cancel deferred responses");
+      await implementation.cancelDeferred(model, handle, options);
+    };
+  }
+  return api;
 }
 
 // node_modules/@earendil-works/pi-ai/dist/auth/context.js
@@ -86,38 +103,93 @@ function defaultProviderAuthContext() {
   };
 }
 
+// node_modules/@earendil-works/pi-ai/dist/utils/abort.js
+function abortReason(signal) {
+  if (signal.reason !== undefined)
+    return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function operationSignal(signal) {
+  return signal ?? new AbortController().signal;
+}
+function raceWithAbortSignal(operation, signal) {
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(abortReason(signal));
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(abortReason(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then((value) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+    if (signal.aborted)
+      onAbort();
+  });
+}
+
 // node_modules/@earendil-works/pi-ai/dist/auth/credential-store.js
 class InMemoryCredentialStore {
   credentials = new Map;
   chains = new Map;
-  enqueue(providerId, task) {
+  enqueue(providerId, task, options) {
+    const signal = operationSignal(options?.signal);
     const previous = this.chains.get(providerId) ?? Promise.resolve();
-    const next = (async () => {
+    const queued = (async () => {
       await previous.catch(() => {});
+      signal.throwIfAborted();
       return task();
     })();
-    this.chains.set(providerId, next.catch(() => {}));
-    return next;
+    const tail = queued.catch(() => {});
+    this.chains.set(providerId, tail);
+    tail.then(() => {
+      if (this.chains.get(providerId) === tail)
+        this.chains.delete(providerId);
+    });
+    return raceWithAbortSignal(queued, signal);
   }
-  async read(providerId) {
+  async read(providerId, options) {
+    options?.signal?.throwIfAborted();
     return this.credentials.get(providerId);
   }
-  async list() {
+  async list(options) {
+    options?.signal?.throwIfAborted();
     return [...this.credentials].map(([providerId, credential]) => ({ providerId, type: credential.type }));
   }
-  modify(providerId, fn) {
+  modify(providerId, fn, options) {
     return this.enqueue(providerId, async () => {
       const current = this.credentials.get(providerId);
       const next = await fn(current);
+      options?.signal?.throwIfAborted();
       if (next !== undefined)
         this.credentials.set(providerId, next);
       return next ?? current;
-    });
+    }, options);
   }
-  delete(providerId) {
+  delete(providerId, options) {
     return this.enqueue(providerId, async () => {
       this.credentials.delete(providerId);
-    });
+    }, options);
   }
 }
 
@@ -138,27 +210,32 @@ function withCauseDetail(message, cause) {
     return message;
   return `${message}: ${detail}`;
 }
-async function resolveProviderAuth(provider, credentials, authContext, overrides) {
+function resolveProviderAuth(provider, credentials, authContext, overrides) {
+  const signal = operationSignal(overrides?.signal);
+  return raceWithAbortSignal(resolveProviderAuthWithSignal(provider, credentials, authContext, overrides, signal), signal);
+}
+async function resolveProviderAuthWithSignal(provider, credentials, authContext, overrides, signal) {
+  signal.throwIfAborted();
   const requestAuthContext = overrides?.env ? overlayEnvAuthContext(authContext, overrides.env) : authContext;
   if (overrides?.apiKey !== undefined && provider.auth.apiKey) {
     return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, {
       type: "api_key",
       key: overrides.apiKey,
       env: overrides.env
-    });
+    }, signal);
   }
-  const stored = await readCredential(credentials, provider.id);
+  const stored = await readCredential(credentials, provider.id, signal);
   if (stored) {
     if (stored.type === "oauth" && provider.auth.oauth) {
-      return resolveStoredOAuth(credentials, provider.id, provider.auth.oauth, stored, overrides?.minOAuthValidityMs);
+      return resolveStoredOAuth(credentials, provider.id, provider.auth.oauth, stored, signal, overrides?.minOAuthValidityMs);
     }
     if (stored.type === "api_key" && provider.auth.apiKey) {
       const credential = overrides?.env ? { ...stored, env: { ...stored.env, ...overrides.env } } : stored;
-      return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, credential);
+      return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, credential, signal);
     }
     return;
   }
-  return provider.auth.apiKey ? resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, undefined) : undefined;
+  return provider.auth.apiKey ? resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, undefined, signal) : undefined;
 }
 function overlayEnvAuthContext(base, env) {
   return {
@@ -167,7 +244,8 @@ function overlayEnvAuthContext(base, env) {
   };
 }
 var DEFAULT_OAUTH_MINIMUM_VALIDITY_MS = 5 * 60 * 1000;
-async function resolveStoredOAuth(credentials, providerId, oauth, stored, minOAuthValidityMs) {
+var DEFAULT_OAUTH_REFRESH_TIMEOUT_MS = 15000;
+async function resolveStoredOAuth(credentials, providerId, oauth, stored, signal, minOAuthValidityMs) {
   const minimumValidityMs = Math.max(DEFAULT_OAUTH_MINIMUM_VALIDITY_MS, minOAuthValidityMs ?? 0);
   const expiresSoon = (credential2) => Date.now() + minimumValidityMs >= credential2.expires;
   let credential = stored;
@@ -180,11 +258,15 @@ async function resolveStoredOAuth(credentials, providerId, oauth, stored, minOAu
         if (!expiresSoon(current))
           return;
         try {
-          return await oauth.refresh(current);
+          const refreshSignal = AbortSignal.any([
+            signal,
+            AbortSignal.timeout(DEFAULT_OAUTH_REFRESH_TIMEOUT_MS)
+          ]);
+          return await oauth.refresh(current, refreshSignal);
         } catch (error) {
           throw new ModelsError("oauth", `OAuth refresh failed for ${providerId}`, { cause: error });
         }
-      });
+      }, { signal });
     } catch (error) {
       if (error instanceof ModelsError)
         throw error;
@@ -203,16 +285,16 @@ async function resolveStoredOAuth(credentials, providerId, oauth, stored, minOAu
     throw new ModelsError("oauth", `OAuth auth derivation failed for ${providerId}`, { cause: error });
   }
 }
-async function resolveApiKey(authContext, apiKey, providerId, credential) {
+async function resolveApiKey(authContext, apiKey, providerId, credential, signal) {
   try {
-    return await apiKey.resolve({ ctx: authContext, credential });
+    return await apiKey.resolve({ ctx: authContext, credential, signal });
   } catch (error) {
     throw new ModelsError("auth", `API key auth failed for provider ${providerId}`, { cause: error });
   }
 }
-async function readCredential(credentials, providerId) {
+async function readCredential(credentials, providerId, signal) {
   try {
-    return await credentials.read(providerId);
+    return await credentials.read(providerId, { signal });
   } catch (error) {
     throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
   }
@@ -221,14 +303,17 @@ async function readCredential(credentials, providerId) {
 // node_modules/@earendil-works/pi-ai/dist/models-store.js
 class InMemoryModelsStore {
   entries = new Map;
-  async read(providerId) {
+  async read(providerId, options) {
+    options?.signal?.throwIfAborted();
     const entry = this.entries.get(providerId);
     return entry ? structuredClone(entry) : undefined;
   }
-  async write(providerId, entry) {
+  async write(providerId, entry, options) {
+    options?.signal?.throwIfAborted();
     this.entries.set(providerId, structuredClone(entry));
   }
-  async delete(providerId) {
+  async delete(providerId, options) {
+    options?.signal?.throwIfAborted();
     this.entries.delete(providerId);
   }
 }
@@ -254,18 +339,26 @@ class ModelsImpl {
   credentials;
   modelsStore;
   authContext;
+  refreshGenerations = new Map;
+  refreshControllers = new Map;
+  publicationChains = new Map;
   constructor(options) {
     this.credentials = options?.credentials ?? new InMemoryCredentialStore;
     this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore;
     this.authContext = options?.authContext ?? defaultProviderAuthContext();
   }
   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() {
@@ -296,80 +389,139 @@ 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);
+    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;
+        }
+        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 {}
+      } 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;
-      if (!allowNetwork || Date.now() < stored.expires)
+      if (Date.now() < stored.expires)
         return stored;
-      if (signal?.aborted)
+      if (signal.aborted)
         return;
       const post = await this.credentials.modify(provider.id, async (current) => {
         if (current?.type !== "oauth" || Date.now() < current.expires)
           return;
         return oauth.refresh(current, signal);
-      });
+      }, { signal });
       return post?.type === "oauth" ? post : undefined;
     }
     const apiKey = provider.auth.apiKey;
     if (!apiKey)
       return;
     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;
     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) {
     if (credential?.type === "oauth") {
       return provider.auth.oauth ? { source: "OAuth", type: "oauth" } : undefined;
     }
@@ -380,40 +532,52 @@ class ModelsImpl {
       try {
         return await apiKey.check({
           ctx: this.authContext,
-          credential: credential?.type === "api_key" ? credential : undefined
+          credential: credential?.type === "api_key" ? credential : undefined,
+          signal
         });
       } catch (error) {
         throw new ModelsError("auth", `API key auth check failed for provider ${provider.id}`, { cause: error });
       }
     }
-    const resolution = await resolveProviderAuth(provider, this.credentials, this.authContext);
+    const resolution = await resolveProviderAuth(provider, this.credentials, this.authContext, { signal });
     return resolution ? { source: resolution.source, type: "api_key" } : undefined;
   }
-  async checkAuth(providerId) {
-    const provider = this.providers.get(providerId);
-    if (!provider)
-      return;
-    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;
+      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;
-    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 {
@@ -425,6 +589,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}`);
@@ -432,18 +598,50 @@ 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 });
+    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 });
+        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 });
     }
   }
@@ -458,7 +656,8 @@ class ModelsImpl {
     this.requireProvider(model);
     const resolution = await this.getAuth(model, {
       apiKey: options?.apiKey,
-      env: options?.env
+      env: options?.env,
+      signal: options?.signal
     });
     if (!resolution) {
       throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
@@ -494,6 +693,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);
+  }
 }
 function createModels(options) {
   return new ModelsImpl(options);
@@ -501,7 +718,6 @@ function createModels(options) {
 function createProvider(input) {
   const baselineModels = input.models;
   let dynamicModels = [];
-  let inflightRefresh;
   const fetchModels = input.fetchModels;
   const currentModels = () => {
     const merged = [...baselineModels];
@@ -518,45 +734,68 @@ function createProvider(input) {
   const byApi = single ? undefined : input.api;
   const apiFor = (model) => single ?? byApi?.[model.api];
   const dispatch = (model, run) => {
-    const streams = apiFor(model);
-    if (!streams) {
+    const streams2 = apiFor(model);
+    if (!streams2) {
       return lazyStream(model, async () => {
         throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
       });
     }
-    return run(streams);
+    return run(streams2);
   };
-  return {
+  const provider = {
     id: input.id,
     name: input.name ?? input.id,
     baseUrl: input.baseUrl,
     headers: input.headers,
     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);
+    refreshModels: fetchModels ? 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;
           }
-          if (!context.allowNetwork || context.signal?.aborted)
-            return;
-          const refreshed = await fetchModels(context);
-          if (context.signal?.aborted)
-            return;
+        })) {
+          return;
+        }
+      }
+      if (!context.allowNetwork || context.signal.aborted)
+        return;
+      const refreshed = await fetchModels(context);
+      if (context.signal.aborted)
+        return;
+      await context.publish({
+        persist: { models: refreshed, checkedAt: Date.now() },
+        update: () => {
           dynamicModels = refreshed;
-          await context.store.write({ models: refreshed, checkedAt: Date.now() });
-        } finally {
-          inflightRefresh = undefined;
         }
-      })();
-      return inflightRefresh;
+      });
     } : 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))
+    stream: (model, context, options) => dispatch(model, (streams2) => streams2.stream(model, context, options)),
+    streamSimple: (model, context, options) => dispatch(model, (streams2) => streams2.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;
 }
 function hasApi(model, api) {
   return model.api === api;