@meistrari/chat-nuxt 4.5.0-rc.2 → 4.5.0-rc.3

package/README.md

@@ -75,6 +75,17 @@ The table below is a quick index for reading in-repo. **When you change a prop,
 
 The embed automatically sets the browser tab title to the active conversation title and synchronizes its ID to `?conversationId=` using router replacement, preserving other query parameters and the URL fragment. Starting a new conversation removes the conversation parameter. Opening or reloading that URL restores the conversation; existing `?conversation=` links are also accepted and converted to `?conversationId=`. Explicit `conversationId` and `initialConversationId` props take precedence over the URL on mount. Without a conversation title, the host application controls the tab title.
 
+The model catalog loads in the background and never gates send, retry or model
+persistence. Its in-memory cache is scoped to workspace, agent, branch,
+conversation scope, conversation and harness. Lists remain fresh for five minutes;
+refresh failures retain the last valid list for up to 24 hours. Browser requests have a 30-second deadline including proxying and harness resolution;
+the backend catalog lookup has a three-second timeout. Requests share one pending
+request per key and back off from 30 seconds
+to five minutes on failure. Mounted consumers periodically refresh the cache.
+Reloading the page starts a new cache. Cold Claude pickers use bundled options;
+Lightweight keeps the configured/restored selection or the agent default. Neither
+harness changes the selected model when catalog metadata arrives.
+
 ### `<MeistrariChatEmbed>` props
 
 Declared in `src/runtime/embed/types.ts`; prop, feature-flag, and event payload types are importable from the package root or `@meistrari/chat-nuxt/types/embed`.
@@ -88,8 +99,8 @@ Declared in `src/runtime/embed/types.ts`; prop, feature-flag, and event payload
 | `initialConversationId` | `string \| null` | `null` | Conversation to open once on mount when `conversationId` is uncontrolled |
 | `conversationScope` | `string \| null` | `null` | Isolate conversation history by technical scope within the current workspace and runtime. Scoped embeds only see same-scope conversations; values are trimmed, blank becomes `null`, and the server accepts 1-200 chars from `A-Z`, `a-z`, `0-9`, `.`, `_`, `:`, `/`, `-` |
 | `defaultConversationCreatorFilter` | `'all' \| 'mine'` | `'all'` | Initial sidebar creator filter: every conversation in scope, or only the current user's |
-| `availableModels` | `AvailableChatModels` | Workspace catalog | Optional ordered subset of models for the active workspace. With the served catalog (lightweight harness), ids the catalog does not offer as available are dropped, and the full catalog is used when none remain; otherwise unknown ids fail at runtime. A restored unavailable selection stays visible and blocked until the user chooses an available model |
-| `defaultModel` | `ChatModel` | Package default | Initial model for untouched drafts. Explicit selections and existing conversations take precedence; `availableModels` still limits the selection |
+| `availableModels` | `AvailableChatModels` | Harness catalog | Visual filter and ordering for catalog options. Unknown ids are omitted; if no ids match, the full catalog is shown. Does not change defaults, restored selections or execution. The Agent validates availability |
+| `defaultModel` | `ChatModel` | Package default | Initial model for untouched drafts. Explicit selections and existing conversations take precedence; `availableModels` only filters the selector |
 | `defaultReasoningEffort` | `ChatReasoningEffort` | Automatic (`null`) | Initial reasoning effort for untouched drafts. Explicit user choices (including automatic) take precedence |
 | `conversationCreatorFilter` | `'all' \| 'mine'` | — | Controlled sidebar creator filter; use with `v-model:conversation-creator-filter` when the host changes it at runtime |
 | `hideConversationCreatorFilter` | `boolean` | `false` | Hide the creator selector without changing the active filter |

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "4.5.0-rc.2",
+  "version": "4.5.0-rc.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/embed/components/chat-embed-inner.vue

@@ -24,8 +24,7 @@ import {
 } from "../../messages/composables/chat";
 import {
   ensureConversationUsesSelectedModel,
-  MODEL_UPDATE_FAILED_MESSAGE,
-  resolveChatModelSelection
+  MODEL_UPDATE_FAILED_MESSAGE
 } from "../../messages/model-availability";
 import { useChatAction } from "../../messages/composables/chat-action";
 import { useChatApi } from "../../shared/composables/chat-api";
@@ -291,7 +290,7 @@ async function waitForPendingReasoningEffortUpdate() {
   }
 }
 function resolveSelectedModel(value) {
-  return nativeModels ? nativeModels.resolve(value) : resolveChatModelSelection(value, embedConfig?.availableModels.value);
+  return nativeModels ? nativeModels.resolve(value) : value;
 }
 const selectedModel = computed({
   get: () => resolveSelectedModel(
@@ -581,7 +580,6 @@ async function dispatchMessage(outbound, files, resolvedAgentInputs) {
     return false;
   let claimedWakeSessionId;
   const sent = await sendMessage(outbound, files.length > 0 ? files : void 0, resolvedAgentInputs, async (signal) => {
-    await nativeModels?.ensureReady();
     if (!activeConversationId.value || !currentConversation.value) {
       const conversation2 = await createConversation({
         model: selectedModel.value,
@@ -669,7 +667,6 @@ async function handleCancel() {
 }
 async function handleRetry(messageId) {
   await retryMessage(messageId, async () => {
-    await nativeModels?.ensureReady();
     await waitForPendingModelUpdate();
     await waitForPendingReasoningEffortUpdate();
     const conversation = currentConversation.value;

package/dist/runtime/embed/components/chat-embed.vue

@@ -102,6 +102,7 @@ provideEmbedConfig({
   messageFeedback: computed(() => props.messageFeedback)
 }, { syncGlobal: !parentEmbedConfig });
 provideChatRequestContext({
+  conversationId: selectedConversationId,
   harness,
   workspaceId,
   telaAgentId: normalizedTelaAgentId,

package/dist/runtime/embed/composables/harness-adapter.d.ts

@@ -1,6 +1,5 @@
 import type { useChat } from '../../messages/composables/chat.js';
 type ChatModelPolicy = {
-    ensureReady: () => Promise<void>;
     resolve: (value: string | null) => string | null;
     ensureSelectedModel: (current: string | null, selected: string | null, persist: (value: string | null) => Promise<boolean>) => Promise<void>;
 };

package/dist/runtime/embed/types.d.ts

@@ -86,14 +86,13 @@ export type ChatEmbedSharedProps = {
      */
     defaultConversationCreatorFilter?: ConversationCreatorFilter;
     /**
-     * Optional non-empty ordered subset of the models served for the active workspace.
-     * Unknown ids fail at runtime. A restored unavailable selection stays visible and
-     * blocked until the user chooses an available model.
+     * Visual filter and ordering for the Agent catalog. If no ids match, the full
+     * catalog is shown. Does not change defaults, restored selections or execution;
+     * the Agent validates model availability.
      */
     availableModels?: AvailableChatModels;
     /**
      * Initial model for untouched drafts. Existing conversations and explicit selections take precedence.
-     * When excluded by availableModels, the first allowed model is used.
      */
     defaultModel?: string;
     /**

package/dist/runtime/lightweight/embed/composables/model-selection.d.ts

@@ -1,5 +1,4 @@
 export declare function useLightweightModelSelection(): {
-    ensureReady: () => Promise<void>;
-    resolve: (selection: string | null) => any;
+    resolve: (selection: string | null) => string | null;
     ensureSelectedModel: (current: string | null, selected: string | null, persist: (value: string | null) => Promise<boolean>) => Promise<void>;
 };

package/dist/runtime/lightweight/embed/composables/model-selection.js

@@ -1,29 +1,12 @@
-import { useEmbedConfig } from "../../../embed/composables/embed-config.js";
 import { useChatModelCatalog } from "../../messages/composables/chat-model-catalog.js";
-import { ensureConversationUsesSelectedModel, resolveAvailableChatModels } from "../../../messages/model-availability.js";
+import { ensureConversationUsesSelectedModel } from "../../../messages/model-availability.js";
 export function useLightweightModelSelection() {
-  const embedConfig = useEmbedConfig();
-  const { scopeKey, models, defaultModel, isLoaded, load } = useChatModelCatalog();
-  let ready = Promise.resolve();
-  const failed = ref(false);
+  const { scopeKey, load } = useChatModelCatalog();
   watch(scopeKey, () => {
-    const scope = scopeKey.value;
-    failed.value = false;
-    ready = load().catch(() => {
-      if (scopeKey.value === scope)
-        failed.value = true;
-    });
+    void load();
   }, { immediate: true });
-  const available = computed(() => models.value.length ? resolveAvailableChatModels(embedConfig?.availableModels.value, models.value.map((model) => model.id)) : []);
-  const fallback = computed(() => available.value.includes(defaultModel.value ?? "") ? defaultModel.value : available.value[0] ?? null);
-  async function ensureReady() {
-    await ready;
-    if (failed.value || !isLoaded.value || !models.value.length)
-      throw new Error("N\xE3o foi poss\xEDvel carregar os modelos dispon\xEDveis neste workspace");
-  }
   return {
-    ensureReady,
-    resolve: (selection) => selection ?? fallback.value,
-    ensureSelectedModel: (current, selected, persist) => ensureConversationUsesSelectedModel(current, selected, persist, available.value)
+    resolve: (selection) => selection,
+    ensureSelectedModel: (current, selected, persist) => ensureConversationUsesSelectedModel(current, selected, persist)
   };
 }

package/dist/runtime/lightweight/messages/composables/chat-model-catalog.d.ts

@@ -1,10 +1,8 @@
 export declare function useChatModelCatalog(): {
-    scopeKey: any;
     models: any;
     defaultModel: any;
-    isLoaded: any;
-    isLoading: any;
-    load: (options?: {
-        force?: boolean;
-    }) => Promise<void>;
+    scopeKey: Readonly<import("vue").Ref<string, string>>;
+    isLoaded: Readonly<import("vue").Ref<boolean, boolean>>;
+    isLoading: Readonly<import("vue").Ref<any, any>>;
+    load: () => Promise<void>;
 };

package/dist/runtime/lightweight/messages/composables/chat-model-catalog.js

@@ -1,55 +1,8 @@
 import { chatModelsResponseSchema } from "../../../types/schemas/chat/lightweight-models.js";
-import { useChatApi } from "../../../shared/composables/chat-api.js";
-const pendingLoadsByCatalogState = /* @__PURE__ */ new WeakMap();
+import { useModelCatalogCache } from "../../../messages/composables/model-catalog-cache.js";
 export function useChatModelCatalog() {
-  const chatApi = useChatApi();
-  const catalogs = useState("chat-model-catalogs", () => ({}));
-  const loadedCatalogs = useState("chat-model-catalogs-loaded", () => ({}));
-  const loadingCatalogs = useState("chat-model-catalogs-loading", () => ({}));
-  let pendingLoads = pendingLoadsByCatalogState.get(catalogs);
-  if (!pendingLoads) {
-    pendingLoads = /* @__PURE__ */ new Map();
-    pendingLoadsByCatalogState.set(catalogs, pendingLoads);
-  }
-  const catalogKey = computed(
-    () => chatApi.withChatHeaders().headers?.["x-chat-workspace-id"] ?? "__default__"
-  );
-  const models = computed(() => (catalogs.value[catalogKey.value] ?? []).filter((model) => model.status === "available"));
-  const isLoaded = computed(() => loadedCatalogs.value[catalogKey.value] ?? false);
-  const isLoading = computed(() => loadingCatalogs.value[catalogKey.value] ?? false);
-  const defaultModel = computed(
-    () => models.value.find((model) => model.isDefault)?.id ?? models.value[0]?.id ?? null
-  );
-  async function load(options = {}) {
-    const requestOptions = chatApi.withChatHeaders();
-    const key = requestOptions.headers?.["x-chat-workspace-id"] ?? "__default__";
-    const pending = pendingLoads.get(key);
-    if (pending)
-      return pending;
-    if (loadedCatalogs.value[key] && !options.force)
-      return;
-    loadingCatalogs.value = { ...loadingCatalogs.value, [key]: true };
-    const request = Promise.resolve().then(async () => {
-      const response = await $fetch(chatApi.path("/models"), requestOptions);
-      catalogs.value = {
-        ...catalogs.value,
-        [key]: chatModelsResponseSchema.parse(response).models
-      };
-      loadedCatalogs.value = { ...loadedCatalogs.value, [key]: true };
-    }).finally(() => {
-      loadingCatalogs.value = { ...loadingCatalogs.value, [key]: false };
-      if (pendingLoads.get(key) === request)
-        pendingLoads.delete(key);
-    });
-    pendingLoads.set(key, request);
-    return request;
-  }
-  return {
-    scopeKey: readonly(catalogKey),
-    models: readonly(models),
-    defaultModel,
-    isLoaded: readonly(isLoaded),
-    isLoading: readonly(isLoading),
-    load
-  };
+  const catalog = useModelCatalogCache("lightweight", (response) => chatModelsResponseSchema.parse(response).models, []);
+  const models = computed(() => catalog.models.value.filter((model) => model.status === "available"));
+  const defaultModel = computed(() => models.value.find((model) => model.isDefault)?.id ?? models.value[0]?.id ?? null);
+  return { ...catalog, models: readonly(models), defaultModel };
 }

package/dist/runtime/lightweight/messages/model-options.d.ts

@@ -7,6 +7,10 @@ type BuildChatModelOptionsInput = {
     providerIcons: Readonly<Record<string, Component>>;
 };
 export declare function buildChatModelOptions(input: BuildChatModelOptionsInput): ({
+    value: string;
+    label: string;
+    tabs: string[];
+} | {
     isMultiModal: any;
     tabs: string[];
     maxOutputTokens?: any;
@@ -17,11 +21,5 @@ export declare function buildChatModelOptions(input: BuildChatModelOptionsInput)
     icon: Component | undefined;
     cost: any;
     maxInputTokens: any;
-} | {
-    value: string;
-    label: string;
-    description: string;
-    group: string;
-    tabs: string[];
 })[];
 export {};

package/dist/runtime/lightweight/messages/model-options.js

@@ -1,15 +1,10 @@
 import { resolveAvailableChatModels } from "../../messages/model-availability.js";
 export function buildChatModelOptions(input) {
-  if (input.models.length === 0)
-    return [];
-  const availableModels = resolveAvailableChatModels(
-    input.availableModels,
-    input.models.map((candidate) => candidate.id)
-  );
+  const availableModels = resolveAvailableChatModels(input.availableModels, input.models.map((candidate) => candidate.id));
   const options = availableModels.map((modelId) => {
     const model = input.models.find((candidate) => candidate.id === modelId);
     if (!model)
-      throw new Error(`${modelId} is missing from the served model catalog`);
+      return { value: modelId, label: modelId, tabs: ["all"] };
     const isMultiModal = model.inputModalities.some((modality) => modality !== "text");
     return {
       value: model.id,
@@ -32,9 +27,7 @@ export function buildChatModelOptions(input) {
     return options;
   return [{
     value: input.selectedModel,
-    label: `${input.selectedModel} (Indispon\xEDvel)`,
-    description: "Selecione um modelo dispon\xEDvel antes de enviar uma mensagem.",
-    group: "Indispon\xEDvel",
+    label: input.selectedModel,
     tabs: ["all"]
   }, ...options];
 }

package/dist/runtime/messages/components/chat-model-selector.vue

@@ -1,8 +1,9 @@
 <script setup>
-import { chatModelOptions } from "../../types/schemas/chat/ui.js";
+import { chatModelTabs } from "../../types/schemas/chat/model-catalog.js";
 import { useEmbedConfig } from "../../embed/composables/embed-config";
+import { useChatModelCatalog } from "../composables/chat-model-catalog";
 import { useChatRequestContext } from "../../shared/composables/chat-request-context";
-import { useChatModelCatalog } from "../../lightweight/messages/composables/chat-model-catalog";
+import { useChatModelCatalog as useLightweightModelCatalog } from "../../lightweight/messages/composables/chat-model-catalog";
 import { buildChatModelOptions } from "../../lightweight/messages/model-options";
 import { resolveAvailableChatModels } from "../model-availability";
 import TelaChatIconsAnthropic from "@meistrari/tela-build/components/tela/chat/icons/anthropic.vue";
@@ -13,12 +14,29 @@ defineProps({
 });
 const model = defineModel({ type: [String, null], ...{ default: null } });
 const embedConfig = useEmbedConfig();
-const lightweightCatalog = useChatRequestContext()?.harness?.value === "lightweight" ? useChatModelCatalog() : null;
+const isLightweight = useChatRequestContext()?.harness?.value === "lightweight";
+const lightweightCatalog = isLightweight ? useLightweightModelCatalog() : null;
+const catalog = isLightweight ? null : useChatModelCatalog();
+const activeCatalog = lightweightCatalog ?? catalog;
 const providerIcons = {
   Anthropic: TelaChatIconsAnthropic,
   OpenAI: TelaChatIconsOpenai,
   Google: TelaChatIconsGemini
 };
+function toOption(entry) {
+  return {
+    value: entry.id,
+    label: entry.label,
+    description: entry.description ?? void 0,
+    group: entry.provider,
+    icon: providerIcons[entry.provider],
+    cost: entry.cost,
+    maxInputTokens: entry.maxInputTokens,
+    maxOutputTokens: entry.maxOutputTokens ?? void 0,
+    isMultiModal: entry.isMultiModal,
+    tabs: chatModelTabs(entry)
+  };
+}
 const options = computed(() => {
   if (lightweightCatalog) {
     return buildChatModelOptions({
@@ -28,23 +46,13 @@ const options = computed(() => {
       providerIcons
     });
   }
-  const availableModels = resolveAvailableChatModels(embedConfig?.availableModels.value);
-  return availableModels.map((model2) => {
-    const option = chatModelOptions.find((candidate) => candidate.value === model2);
-    if (!option)
-      throw new Error(`${model2} is missing from the chat model catalog`);
-    return {
-      value: option.value,
-      label: option.label,
-      description: option.description,
-      group: option.provider,
-      icon: providerIcons[option.provider],
-      cost: option.cost,
-      maxInputTokens: option.maxInputTokens,
-      maxOutputTokens: option.maxOutputTokens,
-      isMultiModal: option.isMultiModal,
-      tabs: [...option.tabs]
-    };
+  if (!catalog)
+    return [];
+  const availableModels = resolveAvailableChatModels(embedConfig?.availableModels.value, catalog.modelIds.value);
+  const optionIds = model.value && !availableModels.includes(model.value) ? [model.value, ...availableModels] : availableModels;
+  return optionIds.map((id) => {
+    const entry = catalog.models.value.find((candidate) => candidate.id === id);
+    return entry ? toOption(entry) : { value: id, label: id, tabs: ["all"] };
   });
 });
 const tabLabels = {
@@ -53,6 +61,9 @@ const tabLabels = {
   cheap: "Econ\xF4micos",
   multimodal: "Multimodal"
 };
+watch(activeCatalog.scopeKey, () => {
+  void activeCatalog.load();
+}, { immediate: true });
 </script>
 
 <template>

package/dist/runtime/messages/composables/chat-model-catalog.d.ts

@@ -0,0 +1,8 @@
+export declare function useChatModelCatalog(): {
+    modelIds: any;
+    scopeKey: Readonly<import("vue").Ref<string, string>>;
+    models: Readonly<import("vue").Ref<any, any>>;
+    isLoaded: Readonly<import("vue").Ref<boolean, boolean>>;
+    isLoading: Readonly<import("vue").Ref<any, any>>;
+    load: () => Promise<void>;
+};

package/dist/runtime/messages/composables/chat-model-catalog.js

@@ -0,0 +1,9 @@
+import { chatModelCatalogResponseSchema, fallbackChatModelCatalog } from "../../types/schemas/chat/model-catalog.js";
+import { useModelCatalogCache } from "./model-catalog-cache.js";
+export function useChatModelCatalog() {
+  const catalog = useModelCatalogCache("claude", (response) => {
+    const parsed = chatModelCatalogResponseSchema.parse(response);
+    return parsed.catalogAvailable ? parsed.models : null;
+  }, fallbackChatModelCatalog);
+  return { ...catalog, modelIds: computed(() => catalog.models.value.map((model) => model.id)) };
+}

package/dist/runtime/messages/composables/chat.js

@@ -420,9 +420,7 @@ export function useChat(options = {}, adapter = {}) {
       const buckets = pendingModelBuckets.value;
       if (chatScope.value in buckets)
         return buckets[chatScope.value] ?? null;
-      const model = embedConfig?.defaultModel?.value ?? (adapter.defaultModel === void 0 ? defaultChatModel : adapter.defaultModel);
-      const allowed = embedConfig?.availableModels?.value;
-      return model && allowed?.length && !allowed.includes(model) ? allowed[0] : model;
+      return embedConfig?.defaultModel?.value ?? (adapter.defaultModel === void 0 ? defaultChatModel : adapter.defaultModel);
     },
     set: (value) => {
       pendingModelBuckets.value = {

package/dist/runtime/messages/composables/model-catalog-cache.d.ts

@@ -0,0 +1,7 @@
+export declare function useModelCatalogCache<T>(harness: 'claude' | 'lightweight', parse: (response: unknown) => T[] | null, fallback: readonly T[]): {
+    scopeKey: Readonly<import("vue").Ref<string, string>>;
+    models: Readonly<import("vue").Ref<any, any>>;
+    isLoaded: Readonly<import("vue").Ref<boolean, boolean>>;
+    isLoading: Readonly<import("vue").Ref<any, any>>;
+    load: () => Promise<void>;
+};

package/dist/runtime/messages/composables/model-catalog-cache.js

@@ -0,0 +1,81 @@
+import { computed, getCurrentInstance, onMounted, onUnmounted, readonly } from "vue";
+import { useChatApi } from "../../shared/composables/chat-api.js";
+const FRESH_MS = 5 * 6e4;
+const RETAIN_MS = 24 * 60 * 6e4;
+const pendingByState = /* @__PURE__ */ new WeakMap();
+export function useModelCatalogCache(harness, parse, fallback) {
+  const chatApi = useChatApi();
+  const entries = useState(`chat-model-catalog-${harness}`, () => ({}));
+  const loading = useState(`chat-model-catalog-${harness}-loading`, () => ({}));
+  let pending = pendingByState.get(entries.value);
+  if (!pending) {
+    pending = /* @__PURE__ */ new Map();
+    pendingByState.set(entries.value, pending);
+  }
+  function requestContext() {
+    const conversationId = chatApi.conversationId?.value;
+    const options = chatApi.withChatHeaders({
+      ...conversationId ? { query: { conversationId } } : {},
+      // This deadline also covers proxying and harness resolution before the upstream catalog timeout starts.
+      timeout: 3e4,
+      retry: 0
+    });
+    const headers = options.headers;
+    const key = JSON.stringify([
+      harness,
+      headers?.["x-chat-workspace-id"],
+      headers?.["x-chat-tela-agent-id"],
+      headers?.["x-chat-tela-agent-branch"],
+      headers?.["x-chat-conversation-scope"],
+      conversationId
+    ]);
+    return { key, options };
+  }
+  const scopeKey = computed(() => requestContext().key);
+  const models = computed(() => entries.value[scopeKey.value]?.models ?? fallback);
+  const isLoaded = computed(() => Boolean(entries.value[scopeKey.value]?.models));
+  const isLoading = computed(() => loading.value[scopeKey.value] ?? false);
+  async function load() {
+    const { key, options } = requestContext();
+    const now = Date.now();
+    for (const [entryKey, entry] of Object.entries(entries.value)) {
+      if (now - (entry.updatedAt ?? entry.attemptedAt) >= RETAIN_MS)
+        delete entries.value[entryKey];
+    }
+    const cached = entries.value[key];
+    if (cached?.updatedAt !== void 0 && now - cached.updatedAt < FRESH_MS)
+      return;
+    if (pending.has(key))
+      return pending.get(key);
+    if (cached && now < cached.retryAt)
+      return;
+    loading.value[key] = true;
+    const request = Promise.resolve().then(async () => {
+      try {
+        const result = parse(await $fetch(chatApi.path("/models"), options));
+        if (!result?.length)
+          throw new Error("Model catalog unavailable");
+        entries.value[key] = { models: result, updatedAt: Date.now(), attemptedAt: Date.now(), retryAt: 0, failures: 0 };
+      } catch {
+        const failures = (cached?.failures ?? 0) + 1;
+        const retained = cached?.updatedAt !== void 0 && Date.now() - cached.updatedAt < RETAIN_MS ? cached : void 0;
+        entries.value[key] = { ...retained, failures, attemptedAt: Date.now(), retryAt: Date.now() + Math.min(3e4 * 2 ** (failures - 1), FRESH_MS) };
+      } finally {
+        delete loading.value[key];
+        pending.delete(key);
+      }
+    });
+    pending.set(key, request);
+    return request;
+  }
+  if (getCurrentInstance()) {
+    let refresh;
+    onMounted(() => {
+      refresh = setInterval(() => {
+        void load();
+      }, FRESH_MS);
+    });
+    onUnmounted(() => clearInterval(refresh));
+  }
+  return { scopeKey: readonly(scopeKey), models: readonly(models), isLoaded: readonly(isLoaded), isLoading: readonly(isLoading), load };
+}

package/dist/runtime/messages/model-availability.d.ts

@@ -1,8 +1,5 @@
 import type { ChatModel } from '../types/schemas/chat/models.js';
 export type AvailableChatModels = readonly [ChatModel, ...ChatModel[]];
 export declare const MODEL_UPDATE_FAILED_MESSAGE = "N\u00E3o foi poss\u00EDvel atualizar o modelo da conversa";
-export declare const MODEL_UNAVAILABLE_MESSAGE = "O modelo selecionado n\u00E3o est\u00E1 dispon\u00EDvel neste workspace";
-export declare function resolveAvailableChatModels(availableModels?: readonly string[]): readonly ChatModel[];
-export declare function resolveAvailableChatModels(availableModels: readonly string[] | undefined, catalogModels: readonly string[]): readonly string[];
-export declare function resolveChatModelSelection(selectedModel: string | null, availableModels?: readonly string[]): string | null;
-export declare function ensureConversationUsesSelectedModel(conversationModel: string | null, selectedModel: string | null, updateModel: (model: string | null) => Promise<boolean>, availableModels?: readonly string[]): Promise<void>;
+export declare function resolveAvailableChatModels(availableModels?: readonly string[], catalogModels?: readonly string[]): readonly string[];
+export declare function ensureConversationUsesSelectedModel(conversationModel: string | null, selectedModel: string | null, updateModel: (model: string | null) => Promise<boolean>): Promise<void>;

package/dist/runtime/messages/model-availability.js

@@ -1,36 +1,13 @@
 import { chatModelIds } from "../types/schemas/chat/models.js";
 export const MODEL_UPDATE_FAILED_MESSAGE = "N\xE3o foi poss\xEDvel atualizar o modelo da conversa";
-export const MODEL_UNAVAILABLE_MESSAGE = "O modelo selecionado n\xE3o est\xE1 dispon\xEDvel neste workspace";
-export function resolveAvailableChatModels(availableModels, catalogModels) {
-  const catalog = catalogModels ?? chatModelIds;
-  if (catalog.length === 0)
-    throw new Error("Agent API model catalog must contain at least one model");
+export function resolveAvailableChatModels(availableModels, catalogModels = chatModelIds) {
+  const catalog = [...new Set(catalogModels)];
   if (availableModels === void 0)
-    return [...new Set(catalog)];
-  if (catalogModels) {
-    const offeredModels = [...new Set(availableModels.filter((model) => catalog.includes(model)))];
-    return offeredModels.length ? offeredModels : [...new Set(catalog)];
-  }
-  if (availableModels.length === 0)
-    throw new Error("availableModels must contain at least one model");
-  const uniqueModels = [];
-  for (const model of availableModels) {
-    if (!catalog.includes(model))
-      throw new Error(`${model} is not a supported chat model`);
-    if (!uniqueModels.includes(model))
-      uniqueModels.push(model);
-  }
-  return uniqueModels;
+    return catalog;
+  const offeredModels = [...new Set(availableModels.filter((model) => catalog.includes(model)))];
+  return offeredModels.length ? offeredModels : catalog;
 }
-export function resolveChatModelSelection(selectedModel, availableModels) {
-  if (availableModels === void 0)
-    return selectedModel;
-  const resolvedModels = resolveAvailableChatModels(availableModels);
-  return selectedModel && resolvedModels.includes(selectedModel) ? selectedModel : resolvedModels[0];
-}
-export async function ensureConversationUsesSelectedModel(conversationModel, selectedModel, updateModel, availableModels) {
-  if (selectedModel && availableModels && !availableModels.includes(selectedModel))
-    throw new Error(MODEL_UNAVAILABLE_MESSAGE);
+export async function ensureConversationUsesSelectedModel(conversationModel, selectedModel, updateModel) {
   if (conversationModel === selectedModel)
     return;
   if (!await updateModel(selectedModel))

package/dist/runtime/shared/composables/chat-api.d.ts

@@ -1,5 +1,6 @@
 export declare function useChatApi(): {
     path: (routePath: string) => string;
+    conversationId: import("vue").ComputedRef<string | null>;
     runtimePath: (routePath: string) => string;
     conversationV2Enabled: boolean;
     withChatHeaders: <const T extends Record<string, any>>(options?: T) => T & {

package/dist/runtime/shared/composables/chat-api.js

@@ -1,3 +1,4 @@
+import { computed } from "vue";
 import { useChatAuth } from "#chat-auth";
 import { useChatRequestContext } from "./chat-request-context.js";
 export function useChatApi() {
@@ -38,6 +39,7 @@ export function useChatApi() {
   }
   return {
     path,
+    conversationId: computed(() => requestContext?.conversationId?.value ?? null),
     runtimePath: (routePath) => `/api/v2${routePath}`,
     conversationV2Enabled: true,
     withChatHeaders

package/dist/runtime/shared/composables/chat-request-context.d.ts

@@ -1,6 +1,7 @@
 import type { ChatHarness } from '../../types/schemas/chat/chat-config.js';
 import type { MaybeRefOrGetter, Ref } from 'vue';
 export type ChatRequestContext = {
+    conversationId?: Ref<string | null>;
     harness?: Ref<ChatHarness | null>;
     workspaceId: Ref<string>;
     telaAgentId: Ref<string | null>;
@@ -8,6 +9,7 @@ export type ChatRequestContext = {
     conversationScope: Ref<string | null>;
 };
 type ChatRequestContextInput = {
+    conversationId?: MaybeRefOrGetter<string | null | undefined>;
     harness?: MaybeRefOrGetter<ChatHarness | null>;
     workspaceId: MaybeRefOrGetter<string | null | undefined>;
     telaAgentId?: MaybeRefOrGetter<string | null | undefined>;

package/dist/runtime/shared/composables/chat-request-context.js

@@ -5,6 +5,7 @@ function normalizeOptionalHeaderValue(value) {
 }
 function useGlobalChatRequestContextState() {
   return {
+    conversationId: useState("chat-request-context-conversation-id", () => null),
     harness: useState("chat-request-context-harness", () => null),
     provided: useState("chat-request-context-provided", () => false),
     workspaceId: useState("chat-request-context-workspace-id", () => ""),
@@ -15,6 +16,7 @@ function useGlobalChatRequestContextState() {
 }
 export function provideChatRequestContext(input, options = {}) {
   const context = {
+    conversationId: computed(() => normalizeOptionalHeaderValue(toValue(input.conversationId))),
     harness: computed(() => toValue(input.harness) ?? null),
     workspaceId: computed(() => normalizeOptionalHeaderValue(toValue(input.workspaceId)) ?? ""),
     telaAgentId: computed(() => normalizeOptionalHeaderValue(toValue(input.telaAgentId))),
@@ -24,6 +26,7 @@ export function provideChatRequestContext(input, options = {}) {
   const globalContext = useGlobalChatRequestContextState();
   if (options.syncGlobal ?? true) {
     watchEffect(() => {
+      globalContext.conversationId.value = context.conversationId.value;
       globalContext.harness.value = context.harness.value;
       globalContext.provided.value = true;
       globalContext.workspaceId.value = context.workspaceId.value;
@@ -42,6 +45,7 @@ export function useChatRequestContext() {
   if (!globalContext.provided.value)
     return null;
   return {
+    conversationId: computed(() => globalContext.conversationId.value),
     harness: computed(() => globalContext.harness.value),
     workspaceId: computed(() => globalContext.workspaceId.value),
     telaAgentId: computed(() => globalContext.telaAgentId.value),

package/dist/runtime/types/schemas/chat/conversations.d.ts

@@ -230,17 +230,7 @@ export declare const conversationWithMessagesSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ConversationWithMessages = z.infer<typeof conversationWithMessagesSchema>;
 export declare const createConversationRequestSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        "claude-opus-5": "claude-opus-5";
-        "claude-opus-5-5": "claude-opus-5-5";
-        "claude-opus-4-8": "claude-opus-4-8";
-        "claude-sonnet-5": "claude-sonnet-5";
-        "claude-sonnet-4-6": "claude-sonnet-4-6";
-        "claude-haiku-4-5": "claude-haiku-4-5";
-        "openai/gpt-5.6-sol": "openai/gpt-5.6-sol";
-        "openai/gpt-5.6-terra": "openai/gpt-5.6-terra";
-        "openai/gpt-5.6-luna": "openai/gpt-5.6-luna";
-    }>>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         low: "low";
         medium: "medium";
@@ -432,17 +422,7 @@ export declare const updateConversationAgentInputsResponseSchema: z.ZodObject<{
 export type UpdateConversationAgentInputsResponse = z.infer<typeof updateConversationAgentInputsResponseSchema>;
 export declare const updateConversationRequestSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        "claude-opus-5": "claude-opus-5";
-        "claude-opus-5-5": "claude-opus-5-5";
-        "claude-opus-4-8": "claude-opus-4-8";
-        "claude-sonnet-5": "claude-sonnet-5";
-        "claude-sonnet-4-6": "claude-sonnet-4-6";
-        "claude-haiku-4-5": "claude-haiku-4-5";
-        "openai/gpt-5.6-sol": "openai/gpt-5.6-sol";
-        "openai/gpt-5.6-terra": "openai/gpt-5.6-terra";
-        "openai/gpt-5.6-luna": "openai/gpt-5.6-luna";
-    }>>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         low: "low";
         medium: "medium";

package/dist/runtime/types/schemas/chat/model-catalog.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const chatModelCatalogEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    provider: z.ZodString;
+    cost: z.ZodNumber;
+    maxInputTokens: z.ZodNumber;
+    maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+    isMultiModal: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChatModelCatalogEntry = z.infer<typeof chatModelCatalogEntrySchema>;
+export declare const chatModelCatalogResponseSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        provider: z.ZodString;
+        cost: z.ZodNumber;
+        maxInputTokens: z.ZodNumber;
+        maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+        isMultiModal: z.ZodBoolean;
+    }, z.core.$strip>>;
+    catalogAvailable: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChatModelCatalogResponse = z.infer<typeof chatModelCatalogResponseSchema>;
+export declare const fallbackChatModelCatalog: readonly ChatModelCatalogEntry[];
+export declare function chatModelTabs(entry: Pick<ChatModelCatalogEntry, 'cost' | 'isMultiModal'>): string[];

package/dist/runtime/types/schemas/chat/model-catalog.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { chatModelOptions } from './ui';
+export const chatModelCatalogEntrySchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    description: z.string().nullable(),
+    provider: z.string().min(1),
+    cost: z.number().int().min(1).max(5),
+    maxInputTokens: z.number().int().positive(),
+    maxOutputTokens: z.number().int().positive().nullable(),
+    isMultiModal: z.boolean(),
+});
+export const chatModelCatalogResponseSchema = z.object({
+    models: z.array(chatModelCatalogEntrySchema).min(1),
+    // False when the bundled fallback is being served instead of the Agent API catalog.
+    catalogAvailable: z.boolean(),
+});
+export const fallbackChatModelCatalog = chatModelOptions.map(option => ({
+    id: option.value,
+    label: option.label,
+    description: option.description,
+    provider: option.provider,
+    cost: option.cost,
+    maxInputTokens: option.maxInputTokens,
+    maxOutputTokens: option.maxOutputTokens,
+    isMultiModal: option.isMultiModal,
+}));
+export function chatModelTabs(entry) {
+    return ['all', entry.cost <= 2 ? 'cheap' : 'advanced', ...(entry.isMultiModal ? ['multimodal'] : [])];
+}

package/dist/runtime/types/schemas/chat/models.d.ts

@@ -1,19 +1,10 @@
 import { z } from 'zod';
 export declare const chatModelIds: readonly ["claude-opus-5", "claude-opus-5-5", "claude-opus-4-8", "claude-sonnet-5", "claude-sonnet-4-6", "claude-haiku-4-5", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-5.6-luna"];
-export declare const chatModelSchema: z.ZodEnum<{
-    "claude-opus-5": "claude-opus-5";
-    "claude-opus-5-5": "claude-opus-5-5";
-    "claude-opus-4-8": "claude-opus-4-8";
-    "claude-sonnet-5": "claude-sonnet-5";
-    "claude-sonnet-4-6": "claude-sonnet-4-6";
-    "claude-haiku-4-5": "claude-haiku-4-5";
-    "openai/gpt-5.6-sol": "openai/gpt-5.6-sol";
-    "openai/gpt-5.6-terra": "openai/gpt-5.6-terra";
-    "openai/gpt-5.6-luna": "openai/gpt-5.6-luna";
-}>;
+export type KnownChatModel = typeof chatModelIds[number];
+export declare const chatModelSchema: z.ZodString;
 export type ChatModel = z.infer<typeof chatModelSchema>;
 export declare const defaultChatModel = "claude-opus-5";
-export declare function isValidChatModel(value: unknown): value is ChatModel;
+export declare function isValidChatModel(value: unknown): value is KnownChatModel;
 export declare const chatReasoningEffortValues: readonly ["low", "medium", "high", "xhigh", "max"];
 export declare const chatReasoningEffortSchema: z.ZodEnum<{
     low: "low";

package/dist/runtime/types/schemas/chat/models.js

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+// Bundled catalog: the chat-api and chat-nuxt fall back to these ids when the
+// Agent API catalog cannot be fetched. The live catalog may offer more.
 export const chatModelIds = [
     'claude-opus-5',
     'claude-opus-5-5',
@@ -10,7 +12,8 @@ export const chatModelIds = [
     'openai/gpt-5.6-terra',
     'openai/gpt-5.6-luna',
 ];
-export const chatModelSchema = z.enum(chatModelIds);
+// Any id the Agent API catalog exposes; the Agent API rejects unknown ones on execute.
+export const chatModelSchema = z.string().trim().min(1);
 export const defaultChatModel = 'claude-opus-5';
 export function isValidChatModel(value) {
     return typeof value === 'string' && chatModelIds.includes(value);

package/dist/runtime/types/schemas/index.d.ts

@@ -8,6 +8,7 @@ export * from './chat/github';
 export { chatModelCatalogEntrySchema, chatModelCatalogResponseSchema, chatModelsResponseSchema, isValidChatModel as isValidLightweightChatModel, chatModelSchema as lightweightChatModelSchema, } from './chat/lightweight-models';
 export type { ChatModelCatalogEntry, ChatModel as LightweightChatModel } from './chat/lightweight-models';
 export * from './chat/messages';
+export { chatModelTabs, fallbackChatModelCatalog } from './chat/model-catalog';
 export * from './chat/models';
 export * from './chat/primitives';
 export * from './chat/titles';

package/dist/runtime/types/schemas/index.js

@@ -7,6 +7,7 @@ export * from './chat/files';
 export * from './chat/github';
 export { chatModelCatalogEntrySchema, chatModelCatalogResponseSchema, chatModelsResponseSchema, isValidChatModel as isValidLightweightChatModel, chatModelSchema as lightweightChatModelSchema, } from './chat/lightweight-models';
 export * from './chat/messages';
+export { chatModelTabs, fallbackChatModelCatalog } from './chat/model-catalog';
 export * from './chat/models';
 export * from './chat/primitives';
 export * from './chat/titles';

package/dist/runtime/types/schemas/integrations/tela-agent-api.d.ts

@@ -274,17 +274,7 @@ export declare const telaAgentSessionSchema: z.ZodObject<{
 export type TelaAgentSession = z.infer<typeof telaAgentSessionSchema>;
 export declare const telaAgentWakeRequestSchema: z.ZodObject<{
     sessionId: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodEnum<{
-        "claude-opus-5": "claude-opus-5";
-        "claude-opus-5-5": "claude-opus-5-5";
-        "claude-opus-4-8": "claude-opus-4-8";
-        "claude-sonnet-5": "claude-sonnet-5";
-        "claude-sonnet-4-6": "claude-sonnet-4-6";
-        "claude-haiku-4-5": "claude-haiku-4-5";
-        "openai/gpt-5.6-sol": "openai/gpt-5.6-sol";
-        "openai/gpt-5.6-terra": "openai/gpt-5.6-terra";
-        "openai/gpt-5.6-luna": "openai/gpt-5.6-luna";
-    }>>;
+    model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type TelaAgentWakeRequest = z.infer<typeof telaAgentWakeRequestSchema>;
 export declare const telaAgentWakeResponseSchema: z.ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "4.5.0-rc.2",
+  "version": "4.5.0-rc.3",
   "type": "module",
   "exports": {
     ".": {