@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/{cli-wscdvcqz.js → cli-vctdqs5h.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   init_db
-} from "./cli-47m6dkd3.js";
+} from "./cli-qydf22qq.js";
 
 // src/be/seed-pricing.ts
 init_db();

package/dist/{cli-cw9zck8j.js → cli-xjcywfsf.js}

@@ -1,19 +1,23 @@
 import {
   BASE_SUMMARIZE_PROMPT,
   SummaryWithRatingsSchema,
-  buildSummaryWithRatingsPrompt,
+  buildSummaryWithRatingsPrompt
+} from "./cli-cpvsaqsw.js";
+import {
   parseModelStr,
   resolveCredential
-} from "./cli-tt9k8r35.js";
+} from "./cli-12tszpk9.js";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterBaseUrl
 } from "./cli-3dpj7atn.js";
 import {
   complete,
-  exports_typebox,
   getBuiltinModel
-} from "./cli-aw1jwp1r.js";
+} from "./cli-10nhj6xq.js";
+import {
+  exports_typebox
+} from "./cli-rb9m6rpe.js";
 import {
   init_zod
 } from "./cli-sd0mxa3c.js";

package/dist/{cli-k0g1sjzm.js → cli-ybgv4kw2.js}

@@ -1,6 +1,6 @@
 import {
   getSystemMessageText
-} from "./cli-mcnhgnn1.js";
+} from "./cli-ykk5jaax.js";
 
 // node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
 class UnsupportedStrictJsonSchemaError extends Error {
@@ -41,7 +41,7 @@ function schemaAllowsNull(schema) {
     return true;
   return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
 }
-function makeJsonSchemaNodeStrict(schema) {
+function makeJsonSchemaNodeStrict(schema, isUnsupportedKeyword) {
   if (!isJsonSchemaObject(schema)) {
     throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
   }
@@ -50,6 +50,13 @@ function makeJsonSchemaNodeStrict(schema) {
       throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
     }
   }
+  if (isUnsupportedKeyword) {
+    for (const [key, value] of Object.entries(schema)) {
+      if (isUnsupportedKeyword(key, value)) {
+        throw new UnsupportedStrictJsonSchemaError(`${key}: ${JSON.stringify(value)} is unsupported`);
+      }
+    }
+  }
   if (schema.anyOf !== undefined) {
     if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
       throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
@@ -58,14 +65,14 @@ function makeJsonSchemaNodeStrict(schema) {
       if (isStructuredSchema(variant)) {
         throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
       }
-      makeJsonSchemaNodeStrict(variant);
+      makeJsonSchemaNodeStrict(variant, isUnsupportedKeyword);
     }
   }
   if (schema.items !== undefined) {
     if (Array.isArray(schema.items)) {
       throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
     }
-    makeJsonSchemaNodeStrict(schema.items);
+    makeJsonSchemaNodeStrict(schema.items, isUnsupportedKeyword);
   }
   const isObjectSchema = schema.type === "object";
   if (schema.properties !== undefined && !isObjectSchema) {
@@ -89,7 +96,7 @@ function makeJsonSchemaNodeStrict(schema) {
     throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
   }
   for (const [key, property] of Object.entries(properties)) {
-    makeJsonSchemaNodeStrict(property);
+    makeJsonSchemaNodeStrict(property, isUnsupportedKeyword);
     if (!required.has(key) && !schemaAllowsNull(property)) {
       properties[key] = { anyOf: [property, { type: "null" }] };
     }
@@ -97,12 +104,12 @@ function makeJsonSchemaNodeStrict(schema) {
   schema.required = propertyNames;
   schema.additionalProperties = false;
 }
-function makeStrictJsonSchema(schema) {
+function makeStrictJsonSchema(schema, isUnsupportedKeyword) {
   const cloned = structuredClone(schema);
   if (!isJsonSchemaObject(cloned)) {
     throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
   }
-  makeJsonSchemaNodeStrict(cloned);
+  makeJsonSchemaNodeStrict(cloned, isUnsupportedKeyword);
   if (cloned.type !== "object") {
     throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
   }
@@ -160,13 +167,13 @@ function inferGrammarInputProperty(tool) {
   }
   return inputProperty;
 }
-function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode, isUnsupportedKeyword) {
   const config = tool.constrainedSampling;
   if (!config || config.type !== "json_schema")
     return;
   if (supportsStrictMode) {
     try {
-      makeStrictJsonSchema(tool.parameters);
+      makeStrictJsonSchema(tool.parameters, isUnsupportedKeyword);
       return true;
     } catch (error) {
       if (!(error instanceof UnsupportedStrictJsonSchemaError))
@@ -313,10 +320,9 @@ function clampMaxTokensToContext(model, context, maxTokens) {
   return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
 }
 function buildBaseOptions(model, context, options, apiKey) {
-  const samplingParams = model.samplingParams || options?.samplingParams ? { ...model.samplingParams, ...options?.samplingParams } : undefined;
   return {
     temperature: options?.temperature,
-    samplingParams,
+    samplingParams: options?.samplingParams,
     maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
     signal: options?.signal,
     telemetryContext: options?.telemetryContext,
@@ -328,6 +334,7 @@ function buildBaseOptions(model, context, options, apiKey) {
     headers: options?.headers,
     onPayload: options?.onPayload,
     onResponse: options?.onResponse,
+    onProviderStreamEvent: options?.onProviderStreamEvent,
     timeoutMs: options?.timeoutMs,
     websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
     maxRetries: options?.maxRetries,

package/dist/{cli-rjehvrts.js → cli-ydmcgve1.js}

@@ -1,7 +1,7 @@
 import {
   resolveSlackUserId,
   rewriteSlackMentions
-} from "./cli-8qmme6vd.js";
+} from "./cli-c8a36vcc.js";
 import {
   bufferedFileFailures,
   buildEffectiveText,
@@ -11,7 +11,7 @@ import {
   fetchSlackFiles,
   findUserByExternalId,
   notifySlackFileFailures
-} from "./cli-ftfvggzx.js";
+} from "./cli-9hsgwz4w.js";
 import {
   buildBufferFlushBlocks,
   ensureSlackThreadTree,
@@ -20,7 +20,7 @@ import {
   getSlackApp,
   isSlackRenderV2Enabled,
   registerTreeMessage
-} from "./cli-j57qkrpq.js";
+} from "./cli-azhgzetg.js";
 import {
   createLogEntry,
   getAgentById,
@@ -33,11 +33,11 @@ import {
   init_steering,
   requestSteering,
   slackContextKey
-} from "./cli-47m6dkd3.js";
+} from "./cli-qydf22qq.js";
 import {
   init_steering_enabled,
   isSteeringEnabled
-} from "./cli-ggm92wcn.js";
+} from "./cli-ptr8h7kp.js";
 import {
   __callDispose,
   __using
@@ -173,7 +173,7 @@ function getBufferMessageCount(key) {
 async function instantFlush(key) {
   await slackBuffer.instantFlush(key);
 }
-async function getThreadContextForBuffer(channelId, threadTs, botUserId) {
+async function getThreadContextForBuffer(channelId, threadTs, excludeTs, botUserId) {
   const app = getSlackApp();
   if (!app)
     return "";
@@ -186,7 +186,7 @@ async function getThreadContextForBuffer(channelId, threadTs, botUserId) {
     const messages = result.messages || [];
     if (messages.length === 0)
       return "";
-    const formatted = messages.filter((m) => extractSlackMessageText(m) !== "").map((m) => {
+    const formatted = messages.filter((m) => !(m.ts && excludeTs.has(m.ts)) && extractSlackMessageText(m) !== "").map((m) => {
       const msg = m;
       const isBotMessage = msg.bot_id !== undefined || msg.subtype === "bot_message";
       const text = extractSlackMessageText(m);
@@ -276,7 +276,7 @@ ${combinedText}`;
       return;
     }
     const lead = await getLeadAgent();
-    const threadContext = await getThreadContextForBuffer(channelId, threadTs, botUserId);
+    const threadContext = await getThreadContextForBuffer(channelId, threadTs, new Set(items.map((item) => item.ts)), botUserId);
     const fullDescription = threadContext ? `<thread_context>
 ${threadContext}
 </thread_context>

package/dist/{cli-vhjwh6cz.js → cli-ygwm91nt.js}

@@ -1,7 +1,7 @@
 import {
   codexPlanFromClaim,
   init_subscription_plans
-} from "./cli-cqt19wg6.js";
+} from "./cli-1a2j50m0.js";
 import {
   init_secret_scrubber,
   scrubSecrets

package/dist/{cli-mcnhgnn1.js → cli-ykk5jaax.js}

@@ -380,7 +380,7 @@ class InMemoryCredentialStore {
   }
 }
 
-// node_modules/@earendil-works/pi-ai/dist/auth/resolve.js
+// node_modules/@earendil-works/pi-ai/dist/utils/models-error.js
 class ModelsError extends Error {
   code;
   constructor(code, message, options) {
@@ -397,6 +397,8 @@ function withCauseDetail(message, cause) {
     return message;
   return `${message}: ${detail}`;
 }
+
+// node_modules/@earendil-works/pi-ai/dist/auth/resolve.js
 function resolveProviderAuth(provider, credentials, authContext, overrides) {
   const signal = operationSignal(overrides?.signal);
   return raceWithAbortSignal(resolveProviderAuthWithSignal(provider, credentials, authContext, overrides, signal), signal);
@@ -505,7 +507,59 @@ class InMemoryModelsStore {
   }
 }
 
+// node_modules/@earendil-works/pi-ai/dist/utils/model-operations.js
+function getModelType(model) {
+  return model.type ?? "chat";
+}
+function isModelType(model, type) {
+  return getModelType(model) === type;
+}
+function assertChatModel(model) {
+  if (!isModelType(model, "chat")) {
+    throw new ModelsError("provider", `Model ${model.provider}/${model.id} is not a chat model`);
+  }
+}
+function assertImageModel(model) {
+  if (!isModelType(model, "image")) {
+    throw new ModelsError("provider", `Model ${model.provider}/${model.id} is not an image model`);
+  }
+}
+function assertClassifierModel(model) {
+  if (!isModelType(model, "classifier")) {
+    throw new ModelsError("provider", `Model ${model.provider}/${model.id} is not a classifier model`);
+  }
+}
+function imageErrorResult(model, error, aborted = false) {
+  return {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    output: [],
+    stopReason: aborted ? "aborted" : "error",
+    errorMessage: error instanceof Error ? error.message : String(error),
+    timestamp: Date.now()
+  };
+}
+function classifierErrorResult(model, error, aborted = false) {
+  return {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    answers: {},
+    stopReason: aborted ? "aborted" : "error",
+    errorMessage: error instanceof Error ? error.message : String(error),
+    timestamp: Date.now()
+  };
+}
+
 // node_modules/@earendil-works/pi-ai/dist/models.js
+var KNOWN_MODEL_TYPES = { chat: true, image: true, classifier: true };
+function hasKnownModelType(model) {
+  return Object.hasOwn(KNOWN_MODEL_TYPES, getModelType(model));
+}
+function withKnownModelTypes(entry) {
+  return { ...entry, models: entry.models.filter(hasKnownModelType) };
+}
 function mergeHeaders(base, override) {
   if (!base && !override)
     return;
@@ -573,9 +627,34 @@ class ModelsImpl {
     }
     return models;
   }
+  getAllModels(provider) {
+    if (provider !== undefined) {
+      const entry = this.providers.get(provider);
+      if (!entry)
+        return [];
+      try {
+        return entry.getAllModels?.() ?? entry.getModels();
+      } catch {
+        return [];
+      }
+    }
+    const models = [];
+    for (const entry of this.providers.values()) {
+      try {
+        models.push(...entry.getAllModels?.() ?? entry.getModels());
+      } catch {}
+    }
+    return models;
+  }
+  getModelsOfType(type, provider) {
+    return this.getAllModels(provider).filter((model) => isModelType(model, type));
+  }
   getModel(provider, id) {
     return this.getModels(provider).find((model) => model.id === id);
   }
+  getModelOfType(type, provider, id) {
+    return this.getModelsOfType(type, provider).find((model) => model.id === id);
+  }
   supersedeProviderRefresh(providerId) {
     const generation = (this.refreshGenerations.get(providerId) ?? 0) + 1;
     this.refreshGenerations.set(providerId, generation);
@@ -620,7 +699,7 @@ class ModelsImpl {
     const stored = await this.modelsStore.read(provider.id, { signal });
     await provider.refreshModels({
       credential,
-      stored: stored ? structuredClone(stored) : undefined,
+      stored: stored ? withKnownModelTypes(structuredClone(stored)) : undefined,
       publish: (publication) => this.publishProviderModels(provider.id, generation, signal, publication),
       allowNetwork,
       force: allowNetwork ? force : undefined,
@@ -740,24 +819,45 @@ class ModelsImpl {
     })();
     return raceWithAbortSignal(check, signal);
   }
+  async getAuthenticatedProviders(providerId, signal) {
+    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.filter((entry) => entry.auth !== undefined);
+  }
   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 providers = await this.getAuthenticatedProviders(providerId, signal);
+      return providers.flatMap(({ provider, credential }) => {
         const models = provider.getModels();
         return provider.filterModels?.(models, credential) ?? models;
       });
     })();
     return raceWithAbortSignal(available, signal);
   }
+  async getAvailableOfType(type, providerId, options) {
+    return (await this.getAllAvailable(providerId, options)).filter((model) => isModelType(model, type));
+  }
+  getAllAvailable(providerId, options) {
+    const signal = operationSignal(options?.signal);
+    const available = (async () => {
+      const providers = await this.getAuthenticatedProviders(providerId, signal);
+      return providers.flatMap(({ provider, credential }) => {
+        const models = provider.getAllModels?.() ?? provider.getModels();
+        if (provider.filterAllModels)
+          return provider.filterAllModels(models, credential);
+        if (!provider.filterModels)
+          return models;
+        const availableChatIds = new Set(provider.filterModels(provider.getModels(), credential).map((model) => model.id));
+        return models.filter((model) => !isModelType(model, "chat") || availableChatIds.has(model.id));
+      });
+    })();
+    return raceWithAbortSignal(available, signal);
+  }
   async getAuth(providerOrModel, overrides) {
     const signal = operationSignal(overrides?.signal);
     const providerId = typeof providerOrModel === "string" ? providerOrModel : providerOrModel.provider;
@@ -775,7 +875,7 @@ class ModelsImpl {
       }
     };
   }
-  async login(providerId, type, interaction) {
+  async login(providerId, type, interaction, options) {
     const signal = operationSignal(interaction.signal);
     signal.throwIfAborted();
     const provider = this.providers.get(providerId);
@@ -785,7 +885,7 @@ class ModelsImpl {
     if (!method?.login) {
       throw new ModelsError("auth", `${provider.name} does not support ${type} login`);
     }
-    const loginOperation = method.login({ ...interaction, signal });
+    const loginOperation = method.login({ ...interaction, signal }, options);
     const credential = await raceWithAbortSignal(loginOperation, signal);
     let mutationStarted = false;
     let markMutationStarted;
@@ -839,6 +939,10 @@ class ModelsImpl {
     }
     return provider;
   }
+  requireChatProvider(model) {
+    assertChatModel(model);
+    return this.requireProvider(model);
+  }
   async applyAuth(model, options) {
     this.requireProvider(model);
     const resolution = await this.getAuth(model, {
@@ -863,7 +967,7 @@ class ModelsImpl {
   stream(model, context, options) {
     const transcript = normalizeContext(context);
     return lazyStream(model, async () => {
-      const provider = this.requireProvider(model);
+      const provider = this.requireChatProvider(model);
       const { requestModel, requestOptions } = await this.applyAuth(model, options);
       return provider.stream(requestModel, transcript, requestOptions);
     });
@@ -874,7 +978,7 @@ class ModelsImpl {
   streamSimple(model, context, options) {
     const transcript = normalizeContext(context);
     return lazyStream(model, async () => {
-      const provider = this.requireProvider(model);
+      const provider = this.requireChatProvider(model);
       const { requestModel, requestOptions } = await this.applyAuth(model, options);
       return provider.streamSimple(requestModel, transcript, requestOptions);
     });
@@ -884,7 +988,7 @@ class ModelsImpl {
   }
   streamDeferred(model, handle, options) {
     return lazyStream(model, async () => {
-      const provider = this.requireProvider(model);
+      const provider = this.requireChatProvider(model);
       if (!provider.fetchDeferred) {
         throw new ModelsError("provider", `Provider ${model.provider} does not support deferred responses`);
       }
@@ -896,25 +1000,61 @@ class ModelsImpl {
     return this.streamDeferred(model, handle, options).result();
   }
   async cancelDeferred(model, handle, options) {
-    const provider = this.requireProvider(model);
+    const provider = this.requireChatProvider(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);
   }
+  async generateImages(model, context, options) {
+    try {
+      assertImageModel(model);
+      const provider = this.requireProvider(model);
+      if (!provider.generateImages) {
+        throw new ModelsError("provider", `Provider ${model.provider} does not support image generation`);
+      }
+      const { requestModel, requestOptions } = await this.applyAuth(model, options);
+      return await provider.generateImages(requestModel, context, requestOptions);
+    } catch (error) {
+      return imageErrorResult(model, error, options?.signal?.aborted);
+    }
+  }
+  async classify(model, context, options) {
+    try {
+      assertClassifierModel(model);
+      const provider = this.requireProvider(model);
+      if (!provider.classify) {
+        throw new ModelsError("provider", `Provider ${model.provider} does not support classification`);
+      }
+      const { requestModel, requestOptions } = await this.applyAuth(model, options);
+      return await provider.classify(requestModel, context, requestOptions);
+    } catch (error) {
+      return classifierErrorResult(model, error, options?.signal?.aborted);
+    }
+  }
 }
 function createModels(options) {
   return new ModelsImpl(options);
 }
 function createProvider(input) {
+  const single = input.api && typeof input.api.stream === "function" ? input.api : undefined;
+  const byApi = single || !input.api ? undefined : input.api;
+  const images = input.images;
+  const classifiers = input.classifiers;
+  const streams = single ? [single] : Object.values(byApi ?? {}).filter((entry) => entry !== undefined);
+  const imageImplementations = Object.values(images ?? {}).filter((entry) => entry !== undefined);
+  const classifierImplementations = Object.values(classifiers ?? {}).filter((entry) => entry !== undefined);
+  if (streams.length === 0 && imageImplementations.length === 0 && classifierImplementations.length === 0) {
+    throw new Error(`Provider ${input.id}: at least one of "api", "images", or "classifiers" is required.`);
+  }
   const baselineModels = input.models;
   let dynamicModels = [];
   const fetchModels = input.fetchModels;
   const currentModels = () => {
     const merged = [...baselineModels];
     for (const model of dynamicModels) {
-      const index = merged.findIndex((entry) => entry.id === model.id);
+      const index = merged.findIndex((entry) => getModelType(entry) === getModelType(model) && entry.id === model.id);
       if (index >= 0)
         merged[index] = model;
       else
@@ -922,8 +1062,6 @@ function createProvider(input) {
     }
     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];
   const dispatch = (model, run) => {
     const streams2 = apiFor(model);
@@ -940,7 +1078,8 @@ function createProvider(input) {
     baseUrl: input.baseUrl,
     headers: input.headers,
     auth: input.auth,
-    getModels: currentModels,
+    getModels: () => currentModels().filter((model) => isModelType(model, "chat")),
+    getAllModels: currentModels,
     refreshModels: fetchModels ? async (context) => {
       if (context.stored) {
         const restored = context.stored.models.filter((model) => model.provider === input.id).map((model) => model);
@@ -954,9 +1093,10 @@ function createProvider(input) {
       }
       if (!context.allowNetwork || context.signal.aborted)
         return;
-      const refreshed = await fetchModels(context);
+      const fetched = await fetchModels(context);
       if (context.signal.aborted)
         return;
+      const refreshed = fetched.filter(hasKnownModelType);
       await context.publish({
         persist: { models: refreshed, checkedAt: Date.now() },
         update: () => {
@@ -965,10 +1105,10 @@ function createProvider(input) {
       });
     } : undefined,
     filterModels: input.filterModels,
+    filterAllModels: input.filterAllModels,
     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);
@@ -987,10 +1127,28 @@ function createProvider(input) {
       await implementation.cancelDeferred(model, handle, options);
     };
   }
+  if (images && imageImplementations.length > 0) {
+    provider.generateImages = async (model, context, options) => {
+      const implementation = images[model.api];
+      if (!implementation) {
+        return imageErrorResult(model, new ModelsError("provider", `Provider ${input.id} has no image generation implementation for "${model.api}"`));
+      }
+      return implementation.generateImages(model, context, options);
+    };
+  }
+  if (classifiers && classifierImplementations.length > 0) {
+    provider.classify = async (model, context, options) => {
+      const implementation = classifiers[model.api];
+      if (!implementation) {
+        return classifierErrorResult(model, new ModelsError("provider", `Provider ${input.id} has no classifier implementation for "${model.api}"`));
+      }
+      return implementation.classify(model, context, options);
+    };
+  }
   return provider;
 }
 function hasApi(model, api) {
-  return model.api === api;
+  return isModelType(model, "chat") && model.api === api;
 }
 function calculateCost(model, usage) {
   const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
@@ -1046,7 +1204,7 @@ function clampThinkingLevel(model, level) {
 function modelsAreEqual(a, b) {
   if (!a || !b)
     return false;
-  return a.id === b.id && a.provider === b.provider;
+  return getModelType(a) === getModelType(b) && a.id === b.id && a.provider === b.provider;
 }
 
-export { lazyStream, lazyApi, defaultProviderAuthContext, InMemoryCredentialStore, ModelsError, resolveProviderAuth, InMemoryModelsStore, contentText, getSystemMessageText, renderSystemMessageUpdate, createInitialSystemMessage, normalizeContext, getInitialSystemMessage, withoutInitialSystemMessage, getCurrentTools, getCurrentSystemMessage, getCurrentSystemPrompt, collapseSystemMessages, resolveTranscript, toToolDeclaration, declarationsEqual, getToolStateChanges, getDeclaredTools, hasToolRedefinitions, hasNonAdditiveToolChanges, resolveTranscriptTools, createModels, createProvider, hasApi, calculateCost, getSupportedThinkingLevels, clampThinkingLevel, modelsAreEqual };
+export { lazyStream, lazyApi, defaultProviderAuthContext, InMemoryCredentialStore, ModelsError, InMemoryModelsStore, getModelType, isModelType, assertChatModel, assertImageModel, assertClassifierModel, imageErrorResult, classifierErrorResult, contentText, getSystemMessageText, renderSystemMessageUpdate, createInitialSystemMessage, normalizeContext, getInitialSystemMessage, withoutInitialSystemMessage, getCurrentTools, getCurrentSystemMessage, getCurrentSystemPrompt, collapseSystemMessages, resolveTranscript, toToolDeclaration, declarationsEqual, getToolStateChanges, getDeclaredTools, hasToolRedefinitions, hasNonAdditiveToolChanges, resolveTranscriptTools, createModels, createProvider, hasApi, calculateCost, getSupportedThinkingLevels, clampThinkingLevel, modelsAreEqual };

package/dist/{cli-de1396j2.js → cli-ywybs5as.js}

@@ -35,6 +35,12 @@ function parseModelLimitMessage(text) {
     return;
   return match[1].toLowerCase();
 }
+function parseCreditsRequiredMessage(text) {
+  const match = text.match(/(Fable|Opus|Sonnet)(?:[^.]|\.(?=\d)){0,40}requires usage credits/i);
+  if (!match)
+    return;
+  return match[1].toLowerCase();
+}
 function activeModelBlock(windows, family, nowMs) {
   if (!windows)
     return;
@@ -75,4 +81,4 @@ var init_model_rate_limit_windows = __esm(() => {
   };
 });
 
-export { MODEL_SCOPED_WINDOWS, modelFamilyOf, windowForModelFamily, isModelScopedWindow, parseModelLimitMessage, activeModelBlock, activeModelBlocks, init_model_rate_limit_windows };
+export { MODEL_SCOPED_WINDOWS, modelFamilyOf, windowForModelFamily, isModelScopedWindow, parseModelLimitMessage, parseCreditsRequiredMessage, activeModelBlock, activeModelBlocks, init_model_rate_limit_windows };