@desplega.ai/agent-swarm 1.119.3 → 1.119.5

package/dist/{cli-m6pzzhqr.js → cli-1arw00dp.js}

@@ -1,77 +1,6 @@
-// node_modules/@earendil-works/pi-ai/dist/utils/event-stream.js
-class EventStream {
-  queue = [];
-  waiting = [];
-  done = false;
-  finalResultPromise;
-  resolveFinalResult;
-  isComplete;
-  extractResult;
-  constructor(isComplete, extractResult) {
-    this.isComplete = isComplete;
-    this.extractResult = extractResult;
-    this.finalResultPromise = new Promise((resolve) => {
-      this.resolveFinalResult = resolve;
-    });
-  }
-  push(event) {
-    if (this.done)
-      return;
-    if (this.isComplete(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
-    }
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-    } else {
-      this.queue.push(event);
-    }
-  }
-  end(result) {
-    this.done = true;
-    if (result !== undefined) {
-      this.resolveFinalResult(result);
-    }
-    while (this.waiting.length > 0) {
-      const waiter = this.waiting.shift();
-      waiter({ value: undefined, done: true });
-    }
-  }
-  async* [Symbol.asyncIterator]() {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift();
-      } else if (this.done) {
-        return;
-      } else {
-        const result = await new Promise((resolve) => this.waiting.push(resolve));
-        if (result.done)
-          return;
-        yield result.value;
-      }
-    }
-  }
-  result() {
-    return this.finalResultPromise;
-  }
-}
-
-class AssistantMessageEventStream extends EventStream {
-  constructor() {
-    super((event) => event.type === "done" || event.type === "error", (event) => {
-      if (event.type === "done") {
-        return event.message;
-      } else if (event.type === "error") {
-        return event.error;
-      }
-      throw new Error("Unexpected event type for final result");
-    });
-  }
-}
-function createAssistantMessageEventStream() {
-  return new AssistantMessageEventStream;
-}
+import {
+  AssistantMessageEventStream
+} from "./cli-qs7nb3zn.js";
 
 // node_modules/@earendil-works/pi-ai/dist/api/lazy.js
 function createSetupErrorMessage(model, error) {
@@ -94,19 +23,18 @@ function createSetupErrorMessage(model, error) {
     timestamp: Date.now()
   };
 }
-function forwardStream(target, source) {
-  (async () => {
-    for await (const event of source) {
-      target.push(event);
-    }
-    target.end();
-  })();
+function hasResult(source) {
+  return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+  for await (const event of source) {
+    target.push(event);
+  }
+  target.end(hasResult(source) ? await source.result() : undefined);
 }
 function lazyStream(model, setup) {
   const outer = new AssistantMessageEventStream;
-  setup().then((inner) => {
-    forwardStream(outer, inner);
-  }).catch((error) => {
+  setup().then((inner) => forwardStream(outer, inner)).catch((error) => {
     const message = createSetupErrorMessage(model, error);
     outer.push({ type: "error", reason: "error", error: message });
     outer.end(message);
@@ -173,6 +101,9 @@ class InMemoryCredentialStore {
   async read(providerId) {
     return this.credentials.get(providerId);
   }
+  async list() {
+    return [...this.credentials].map(([providerId, credential]) => ({ providerId, type: credential.type }));
+  }
   modify(providerId, fn) {
     return this.enqueue(providerId, async () => {
       const current = this.credentials.get(providerId);
@@ -198,10 +129,10 @@ class ModelsError extends Error {
     this.code = code;
   }
 }
-async function resolveProviderAuth(provider, model, credentials, authContext, overrides) {
+async function resolveProviderAuth(provider, credentials, authContext, overrides) {
   const requestAuthContext = overrides?.env ? overlayEnvAuthContext(authContext, overrides.env) : authContext;
   if (overrides?.apiKey !== undefined && provider.auth.apiKey) {
-    return resolveApiKey(requestAuthContext, provider.auth.apiKey, model, {
+    return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, {
       type: "api_key",
       key: overrides.apiKey,
       env: overrides.env
@@ -214,11 +145,11 @@ async function resolveProviderAuth(provider, model, credentials, authContext, ov
     }
     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, model, credential);
+      return resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, credential);
     }
     return;
   }
-  return provider.auth.apiKey ? resolveApiKey(requestAuthContext, provider.auth.apiKey, model, undefined) : undefined;
+  return provider.auth.apiKey ? resolveApiKey(requestAuthContext, provider.auth.apiKey, provider.id, undefined) : undefined;
 }
 function overlayEnvAuthContext(base, env) {
   return {
@@ -257,11 +188,11 @@ async function resolveStoredOAuth(credentials, providerId, oauth, stored) {
     throw new ModelsError("oauth", `OAuth auth derivation failed for ${providerId}`, { cause: error });
   }
 }
-async function resolveApiKey(authContext, apiKey, model, credential) {
+async function resolveApiKey(authContext, apiKey, providerId, credential) {
   try {
-    return await apiKey.resolve({ model, ctx: authContext, credential });
+    return await apiKey.resolve({ ctx: authContext, credential });
   } catch (error) {
-    throw new ModelsError("auth", `API key auth failed for provider ${model.provider}`, { cause: error });
+    throw new ModelsError("auth", `API key auth failed for provider ${providerId}`, { cause: error });
   }
 }
 async function readCredential(credentials, providerId) {
@@ -272,13 +203,45 @@ async function readCredential(credentials, providerId) {
   }
 }
 
+// node_modules/@earendil-works/pi-ai/dist/models-store.js
+class InMemoryModelsStore {
+  entries = new Map;
+  async read(providerId) {
+    const entry = this.entries.get(providerId);
+    return entry ? structuredClone(entry) : undefined;
+  }
+  async write(providerId, entry) {
+    this.entries.set(providerId, structuredClone(entry));
+  }
+  async delete(providerId) {
+    this.entries.delete(providerId);
+  }
+}
+
 // node_modules/@earendil-works/pi-ai/dist/models.js
+function mergeHeaders(base, override) {
+  if (!base && !override)
+    return;
+  const merged = { ...base };
+  for (const [name, value] of Object.entries(override ?? {})) {
+    const lowerName = name.toLowerCase();
+    for (const existingName of Object.keys(merged)) {
+      if (existingName.toLowerCase() === lowerName)
+        delete merged[existingName];
+    }
+    merged[name] = value;
+  }
+  return merged;
+}
+
 class ModelsImpl {
   providers = new Map;
   credentials;
+  modelsStore;
   authContext;
   constructor(options) {
     this.credentials = options?.credentials ?? new InMemoryCredentialStore;
+    this.modelsStore = options?.modelsStore ?? new InMemoryModelsStore;
     this.authContext = options?.authContext ?? defaultProviderAuthContext();
   }
   setProvider(provider) {
@@ -318,27 +281,156 @@ class ModelsImpl {
   getModel(provider, id) {
     return this.getModels(provider).find((model) => model.id === id);
   }
-  async refresh(provider) {
-    if (provider !== undefined) {
-      const entry = this.providers.get(provider);
-      if (!entry?.refreshModels)
+  async refresh(options = {}) {
+    const allowNetwork = options.allowNetwork ?? true;
+    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 {
-        await entry.refreshModels();
+        stored = await this.readCredential(provider.id);
+        const credential = await this.resolveRefreshCredential(provider, stored, allowNetwork, options.signal);
+        if (!credential)
+          return;
+        await provider.refreshModels({
+          credential,
+          store,
+          allowNetwork,
+          force: options.force,
+          signal: options.signal
+        });
       } catch (error) {
-        if (error instanceof ModelsError)
-          throw error;
-        throw new ModelsError("model_source", `Model refresh failed for ${provider}`, { cause: error });
+        if (!options.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 {}
       }
+    }));
+    return { aborted: options.signal?.aborted ?? false, errors };
+  }
+  async resolveRefreshCredential(provider, stored, allowNetwork, signal) {
+    if (stored?.type === "oauth") {
+      const oauth = provider.auth.oauth;
+      if (!oauth)
+        return;
+      if (!allowNetwork || Date.now() < stored.expires)
+        return stored;
+      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);
+      });
+      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 });
+    if (!result)
+      return;
+    return { type: "api_key", key: result.auth.apiKey, env: result.env };
+  }
+  async readCredential(providerId) {
+    try {
+      return await this.credentials.read(providerId);
+    } catch (error) {
+      throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
     }
-    await Promise.allSettled(Array.from(this.providers.values(), async (entry) => entry.refreshModels?.()));
   }
-  async getAuth(model) {
-    const provider = this.providers.get(model.provider);
+  async checkProviderAuth(provider, credential) {
+    if (credential?.type === "oauth") {
+      return provider.auth.oauth ? { source: "OAuth", type: "oauth" } : undefined;
+    }
+    const apiKey = provider.auth.apiKey;
+    if (!apiKey)
+      return;
+    if (apiKey.check) {
+      try {
+        return await apiKey.check({
+          ctx: this.authContext,
+          credential: credential?.type === "api_key" ? credential : undefined
+        });
+      } 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);
+    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;
+    });
+  }
+  async getAuth(providerOrModel, overrides) {
+    const providerId = typeof providerOrModel === "string" ? providerOrModel : providerOrModel.provider;
+    const provider = this.providers.get(providerId);
     if (!provider)
       return;
-    return resolveProviderAuth(provider, model, this.credentials, this.authContext);
+    const result = await resolveProviderAuth(provider, this.credentials, this.authContext, overrides);
+    if (!result || typeof providerOrModel === "string" || !providerOrModel.headers)
+      return result;
+    return {
+      ...result,
+      auth: {
+        ...result.auth,
+        headers: mergeHeaders(result.auth.headers, providerOrModel.headers)
+      }
+    };
+  }
+  async login(providerId, type, interaction) {
+    const provider = this.providers.get(providerId);
+    if (!provider)
+      throw new ModelsError("provider", `Unknown provider: ${providerId}`);
+    const method = type === "oauth" ? provider.auth.oauth : provider.auth.apiKey;
+    if (!method?.login) {
+      throw new ModelsError("auth", `${provider.name} does not support ${type} login`);
+    }
+    const credential = await method.login(interaction);
+    try {
+      await this.credentials.modify(providerId, async () => credential);
+    } catch (error) {
+      throw new ModelsError("auth", `Credential store modify failed for ${providerId}`, { cause: error });
+    }
+    return credential;
+  }
+  async logout(providerId) {
+    try {
+      await this.credentials.delete(providerId);
+    } catch (error) {
+      throw new ModelsError("auth", `Credential store delete failed for ${providerId}`, { cause: error });
+    }
   }
   requireProvider(model) {
     const provider = this.providers.get(model.provider);
@@ -348,18 +440,23 @@ class ModelsImpl {
     return provider;
   }
   async applyAuth(model, options) {
-    const resolution = await resolveProviderAuth(this.requireProvider(model), model, this.credentials, this.authContext, {
+    this.requireProvider(model);
+    const resolution = await this.getAuth(model, {
       apiKey: options?.apiKey,
       env: options?.env
     });
-    const auth = resolution?.auth;
-    if (!auth)
-      return { requestModel: model, requestOptions: options };
-    const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+    if (!resolution) {
+      throw new ModelsError("auth", `Provider is not configured: ${model.provider}`);
+    }
+    const auth = resolution.auth;
     const apiKey = options?.apiKey ?? auth.apiKey;
-    const headers = auth.headers || options?.headers ? { ...auth.headers, ...options?.headers } : undefined;
+    let headers = mergeHeaders(auth.headers, options?.headers);
+    if (options?.transformHeaders)
+      headers = await options.transformHeaders(headers ?? {});
     const env = resolution.env || options?.env ? { ...resolution.env ?? {}, ...options?.env ?? {} } : undefined;
-    const requestOptions = { ...options, apiKey, headers, env };
+    const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+    const { transformHeaders: _transformHeaders, ...providerOptions } = options ?? {};
+    const requestOptions = { ...providerOptions, apiKey, headers, env };
     return { requestModel, requestOptions };
   }
   stream(model, context, options) {
@@ -387,9 +484,21 @@ function createModels(options) {
   return new ModelsImpl(options);
 }
 function createProvider(input) {
-  let models = input.models;
+  const baselineModels = input.models;
+  let dynamicModels = [];
   let inflightRefresh;
-  const refreshModels = input.refreshModels;
+  const fetchModels = input.fetchModels;
+  const currentModels = () => {
+    const merged = [...baselineModels];
+    for (const model of dynamicModels) {
+      const index = merged.findIndex((entry) => entry.id === model.id);
+      if (index >= 0)
+        merged[index] = model;
+      else
+        merged.push(model);
+    }
+    return merged;
+  };
   const single = typeof input.api.stream === "function" ? input.api : undefined;
   const byApi = single ? undefined : input.api;
   const apiFor = (model) => single ?? byApi?.[model.api];
@@ -408,17 +517,28 @@ function createProvider(input) {
     baseUrl: input.baseUrl,
     headers: input.headers,
     auth: input.auth,
-    getModels: () => models,
-    refreshModels: refreshModels ? () => {
+    getModels: currentModels,
+    refreshModels: fetchModels ? (context) => {
       inflightRefresh ??= (async () => {
         try {
-          models = await refreshModels();
+          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)
+            return;
+          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))
   };
@@ -427,16 +547,25 @@ function hasApi(model, api) {
   return model.api === api;
 }
 function calculateCost(model, usage) {
+  const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+  let rates = model.cost;
+  let matchedThreshold = -1;
+  for (const tier of model.cost.tiers ?? []) {
+    if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+      rates = tier;
+      matchedThreshold = tier.inputTokensAbove;
+    }
+  }
   const longWrite = usage.cacheWrite1h ?? 0;
   const shortWrite = usage.cacheWrite - longWrite;
-  usage.cost.input = model.cost.input / 1e6 * usage.input;
-  usage.cost.output = model.cost.output / 1e6 * usage.output;
-  usage.cost.cacheRead = model.cost.cacheRead / 1e6 * usage.cacheRead;
-  usage.cost.cacheWrite = (model.cost.cacheWrite * shortWrite + model.cost.input * 2 * longWrite) / 1e6;
+  usage.cost.input = rates.input / 1e6 * usage.input;
+  usage.cost.output = rates.output / 1e6 * usage.output;
+  usage.cost.cacheRead = rates.cacheRead / 1e6 * usage.cacheRead;
+  usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1e6;
   usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
   return usage.cost;
 }
-var EXTENDED_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+var EXTENDED_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 function getSupportedThinkingLevels(model) {
   if (!model.reasoning)
     return ["off"];
@@ -444,7 +573,7 @@ function getSupportedThinkingLevels(model) {
     const mapped = model.thinkingLevelMap?.[level];
     if (mapped === null)
       return false;
-    if (level === "xhigh")
+    if (level === "xhigh" || level === "max")
       return mapped !== undefined;
     return true;
   });
@@ -474,4 +603,4 @@ function modelsAreEqual(a, b) {
   return a.id === b.id && a.provider === b.provider;
 }
 
-export { EventStream, AssistantMessageEventStream, createAssistantMessageEventStream, lazyStream, lazyApi, defaultProviderAuthContext, InMemoryCredentialStore, ModelsError, resolveProviderAuth, createModels, createProvider, hasApi, calculateCost, getSupportedThinkingLevels, clampThinkingLevel, modelsAreEqual };
+export { lazyStream, lazyApi, defaultProviderAuthContext, InMemoryCredentialStore, ModelsError, resolveProviderAuth, InMemoryModelsStore, createModels, createProvider, hasApi, calculateCost, getSupportedThinkingLevels, clampThinkingLevel, modelsAreEqual };

package/dist/{cli-g5a31r9y.js → cli-3brg2qy0.js}

@@ -2,7 +2,7 @@ import {
   getScriptApiTypes,
   getScriptMcpTypes,
   require_typescript
-} from "./cli-gzng1fst.js";
+} from "./cli-7h1sce5x.js";
 import {
   deleteSwarmConfigByKey,
   getAgentById,
@@ -11,7 +11,7 @@ import {
   getSwarmConfigs,
   init_db,
   upsertSwarmConfig
-} from "./cli-y82m27mq.js";
+} from "./cli-rp04sjbc.js";
 import {
   init_secret_scrubber,
   scrubSecrets

package/dist/{cli-9y4z25ke.js → cli-4ntm7f2r.js}

@@ -3,7 +3,7 @@ import {
   getAgentWorkingOnThread,
   getAllAgents,
   init_db
-} from "./cli-y82m27mq.js";
+} from "./cli-rp04sjbc.js";
 
 // src/slack/router.ts
 init_db();

package/dist/{cli-get7n46a.js → cli-4yby3gz2.js}

@@ -1,7 +1,7 @@
 import {
   init_package,
   package_default
-} from "./cli-cx30v78p.js";
+} from "./cli-5sexkty0.js";
 
 // src/commands/shared/client-config.ts
 init_package();

package/dist/{cli-cx30v78p.js → cli-5sexkty0.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "1.119.3",
+    version: "1.119.5",
     description: "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
     license: "MIT",
     author: "desplega.sh <contact@desplega.sh>",
@@ -147,14 +147,14 @@ var init_package = __esm(() => {
       "@aws-sdk/client-bedrock": "3.1048.0",
       "@desplega.ai/business-use": "^0.4.2",
       "@desplega.ai/localtunnel": "^2.2.0",
-      "@earendil-works/pi-agent-core": "^0.80.3",
-      "@earendil-works/pi-ai": "^0.80.3",
-      "@earendil-works/pi-coding-agent": "^0.80.3",
+      "@earendil-works/pi-agent-core": "^0.81.1",
+      "@earendil-works/pi-ai": "^0.81.1",
+      "@earendil-works/pi-coding-agent": "^0.81.1",
       "@inkjs/ui": "^2.0.0",
       "@linear/sdk": "^77.0.0",
       "@modelcontextprotocol/sdk": "^1.25.1",
-      "@openai/codex-sdk": "^0.144.1",
-      "@opencode-ai/sdk": "^1.17.15",
+      "@openai/codex-sdk": "^0.145.0",
+      "@opencode-ai/sdk": "^1.18.4",
       "@openfort/openfort-node": "^0.9.1",
       "@opentelemetry/api": "^1.9.1",
       "@opentelemetry/exporter-metrics-otlp-http": "^0.218.0",

package/dist/{cli-6expbmb3.js → cli-65anxt77.js}

@@ -6,7 +6,7 @@ import {
   getDb,
   init_db,
   isSqliteVecAvailable
-} from "./cli-y82m27mq.js";
+} from "./cli-rp04sjbc.js";
 import {
   __esm,
   __export,

package/dist/{cli-gzng1fst.js → cli-7h1sce5x.js}

@@ -3,7 +3,7 @@ import {
 } from "./cli-jkhwmmgg.js";
 import {
   embedScript
-} from "./cli-xgefj1nz.js";
+} from "./cli-9rrpjvan.js";
 import {
   calculatePKCECodeChallenge,
   generateRandomCodeVerifier,
@@ -22,7 +22,7 @@ import {
   init_date_utils,
   init_db,
   normalizeDateRequired
-} from "./cli-y82m27mq.js";
+} from "./cli-rp04sjbc.js";
 import {
   init_zod
 } from "./cli-bw80ck94.js";
@@ -169081,14 +169081,16 @@ function bindingHasPlaceholder(binding) {
 
 class CredentialBroker {
   store;
-  resolveCredential;
+  resolveConfigCredential;
   defaults;
-  constructor(store, resolveCredential, defaults = []) {
+  resolveOAuthCredential;
+  constructor(store, resolveConfigCredential, defaults = [], resolveOAuthCredential) {
     this.store = store;
-    this.resolveCredential = resolveCredential;
+    this.resolveConfigCredential = resolveConfigCredential;
     this.defaults = defaults;
+    this.resolveOAuthCredential = resolveOAuthCredential;
   }
-  resolveBindings(context) {
+  async resolveBindings(context) {
     const merged = [...this.defaults, ...this.store.listActiveBindings(context)];
     const resolved = [];
     const seen = new Set;
@@ -169097,7 +169099,7 @@ class CredentialBroker {
         continue;
       if (!bindingHasPlaceholder(binding))
         continue;
-      const value = this.resolveCredential(binding.configKey);
+      const value = binding.authKind === "oauth" ? binding.oauthProvider ? await this.resolveOAuthCredential?.(binding.oauthProvider) : undefined : this.resolveConfigCredential(binding.configKey);
       if (!value)
         continue;
       const dedupeKey = [

package/dist/{cli-xgefj1nz.js → cli-9rrpjvan.js}

@@ -4,11 +4,11 @@ import {
   getEmbeddingProvider,
   init_embedding,
   serializeEmbedding
-} from "./cli-6expbmb3.js";
+} from "./cli-65anxt77.js";
 import {
   getDb,
   init_db
-} from "./cli-y82m27mq.js";
+} from "./cli-rp04sjbc.js";
 import {
   init_secret_scrubber,
   scrubSecrets

package/dist/{cli-emgzr4ja.js → cli-ctdx3h19.js}

@@ -27,7 +27,7 @@ import {
   getTaskById,
   init_db,
   setSlackMessageTracking
-} from "./cli-y82m27mq.js";
+} from "./cli-rp04sjbc.js";
 import {
   require_receiver,
   require_sender,
@@ -55073,13 +55073,13 @@ async function initSlackApp() {
     socketMode: true,
     logLevel: import_bolt.LogLevel.DEBUG
   });
-  const { registerMessageHandler } = await import("./handlers-m9jxp50r.js");
-  const { registerCommandHandler } = await import("./commands-14gkjns3.js");
-  const { registerActionHandlers } = await import("./actions-kd321p1j.js");
+  const { registerMessageHandler } = await import("./handlers-jtjhcfec.js");
+  const { registerCommandHandler } = await import("./commands-jc6a4g7b.js");
+  const { registerActionHandlers } = await import("./actions-xqb0w6as.js");
   registerMessageHandler(app);
   registerCommandHandler(app);
   registerActionHandlers(app);
-  const { createAssistant } = await import("./assistant-6w0zb089.js");
+  const { createAssistant } = await import("./assistant-54jkns28.js");
   app.assistant(createAssistant());
   return app;
 }