@8wave/ai-elements 0.112.0-beta.5 → 0.112.0-beta.8

package/dist-vue/locales.js

@@ -228,6 +228,8 @@ var e = {
 		fileUploadMaxFilesPerMessage: "Max files per message",
 		fileUploadMaxFilesPerChat: "Max files per chat",
 		webSearch: "Web search",
+		toolWorkingSet: "Tool selection",
+		toolWorkingSetMode: "Show the agent only the tools a message needs",
 		deprecated: "Deprecated",
 		whatsapp: "WhatsApp",
 		teams: "Microsoft Teams",
@@ -395,6 +397,7 @@ var e = {
 		dismissableNotice: "It will be hidden after the first message.",
 		privacyPolicyNotice: "Displayed at the bottom of the contact form. Supports Markdown.",
 		fileUploadEnabled: "Allow users to attach files to their messages.",
+		toolWorkingSetMode: "Before each reply, an evaluation model (TypeSafe Jev, through the AI gateway) picks the MCP servers, API tools and sub-agents the message needs, and the agent sees only those: a shorter context and quicker replies. When the agent needs another one, it brings it back on its own. In shadow mode the choice is only recorded, to compare it with the tools the agent actually uses.",
 		approvalChannels: "A tool can ask the user to confirm before it runs: expand a tool to turn it on. On API endpoints and scheduled runs the call is refused.",
 		platformSupported: "Renders natively on WhatsApp and Teams",
 		tool: {
@@ -499,6 +502,7 @@ var e = {
 		runSubagent: "Delegating to a sub-agent...",
 		runWorker: "Delegating to a worker...",
 		fetchTeamsChannelHistory: "Reading channel history...",
+		enableTools: "Enabling tools...",
 		searchingDocuments: "Memory search...",
 		expandChunkContext: "Reading more context...",
 		readDocumentFile: "Reading the original document...",
@@ -537,6 +541,23 @@ var e = {
 		expired: "This request is no longer answerable: the action was not performed.",
 		prompt: "Your confirmation is needed to continue:"
 	},
+	toolSelection: {
+		title: "Tool selection",
+		failed: "Failed",
+		exposed: "Exposed",
+		threshold: "threshold {threshold}",
+		latency: "Time",
+		budget: "limit {budget} ms",
+		cost: "Cost",
+		notCharged: "Not charged",
+		inputTokens: "Input tokens",
+		tools: "{n} tool | {n} tools",
+		missed: "Missed",
+		used: "Used",
+		enabled: "Brought back",
+		seeded: "From the conversation",
+		probability: "Probability that the message needs the group; exposed from {threshold}"
+	},
 	validation: { invalidPhoneNumber: "The number entered is incorrect" },
 	showForm: {
 		step: "Step {current} of {total}",
@@ -778,6 +799,8 @@ var e = {
 		fileUploadMaxFilesPerMessage: "File massimi per messaggio",
 		fileUploadMaxFilesPerChat: "File massimi per chat",
 		webSearch: "Ricerca web",
+		toolWorkingSet: "Selezione dei tool",
+		toolWorkingSetMode: "Mostra all’agente solo i tool che servono al messaggio",
 		deprecated: "Deprecato",
 		whatsapp: "WhatsApp",
 		teams: "Microsoft Teams",
@@ -945,6 +968,7 @@ var e = {
 		dismissableNotice: "Verrà nascosto dopo il primo messaggio.",
 		privacyPolicyNotice: "Visibile del modulo di contatto.",
 		fileUploadEnabled: "Permetti agli utenti di allegare file ai messaggi.",
+		toolWorkingSetMode: "Prima di ogni risposta un modello di valutazione (TypeSafe Jev, tramite il gateway AI) sceglie i server MCP, gli API Tools e i sotto-agenti che servono al messaggio, e l’agente vede solo quelli: contesto più corto e risposte più rapide. Quando gliene serve un altro, l’agente lo riattiva da solo. In modalità ombra la scelta viene solo registrata, per confrontarla con i tool che l’agente usa davvero.",
 		approvalChannels: "Un tool può chiedere conferma all'utente prima di eseguire: espandi il tool per attivarla. Via API o in esecuzioni schedulate la chiamata viene rifiutata.",
 		platformSupported: "Resa nativa su WhatsApp e Teams",
 		tool: {
@@ -1049,6 +1073,7 @@ var e = {
 		runSubagent: "Delega a un sotto-agente...",
 		runWorker: "Delega a un worker...",
 		fetchTeamsChannelHistory: "Lettura cronologia canale...",
+		enableTools: "Attivazione dei tool...",
 		searchingDocuments: "Ricerca nella memoria...",
 		expandChunkContext: "Lettura di altro contesto...",
 		readDocumentFile: "Lettura del documento originale...",
@@ -1087,6 +1112,23 @@ var e = {
 		expired: "Questa richiesta non è più confermabile: l'azione non è stata eseguita.",
 		prompt: "Per continuare serve la tua conferma:"
 	},
+	toolSelection: {
+		title: "Selezione dei tool",
+		failed: "Non riuscita",
+		exposed: "Esposti",
+		threshold: "soglia {threshold}",
+		latency: "Tempo",
+		budget: "limite {budget} ms",
+		cost: "Costo",
+		notCharged: "Non addebitata",
+		inputTokens: "Token in ingresso",
+		tools: "{n} tool | {n} tool",
+		missed: "Mancato",
+		used: "Usato",
+		enabled: "Riattivato",
+		seeded: "Dalla conversazione",
+		probability: "Probabilità che il messaggio abbia bisogno del gruppo; esposto da {threshold}"
+	},
 	validation: { invalidPhoneNumber: "Il numero inserito non è corretto" },
 	showForm: {
 		step: "Domanda {current} di {total}",

package/dist-vue/packages/components/src/chat/PkAgentSettingsPanel.d.ts

@@ -1,4 +1,4 @@
-import { AgentFormSettings, AgentReasoning, AgentWebSearch, LocalizedString, Media, ModelCatalogEntry, OrganizationFeature, VoiceOption, AgentBuiltInTool, AgentChannel, AgentLoaderStrategy, AgentType, WebSearchProvider, StoragePolicy } from '../../../models/src';
+import { AgentFormSettings, AgentReasoning, AgentWebSearch, LocalizedString, Media, ModelCatalogEntry, OrganizationFeature, VoiceOption, AgentBuiltInTool, AgentChannel, AgentToolWorkingSetMode, AgentLoaderStrategy, AgentType, WebSearchProvider, StoragePolicy } from '../../../models/src';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     organizationSlug?: string;
@@ -76,6 +76,7 @@ type __VLS_ModelProps = {
     'loadDelay'?: number | undefined;
     'loaderStrategy'?: AgentLoaderStrategy | undefined;
     'fileUploadEnabled'?: boolean;
+    'toolWorkingSetMode'?: AgentToolWorkingSetMode;
     'voiceEnabled'?: boolean;
     'voiceMaxSessionSeconds'?: number;
     'voiceId'?: string | undefined;
@@ -118,9 +119,9 @@ type __VLS_ModelProps = {
     } | undefined;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare var __VLS_749: {};
+declare var __VLS_760: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_749) => any;
+    default?: (props: typeof __VLS_760) => any;
 };
 declare const __VLS_base: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     "update:reasoning": (value: {
@@ -320,6 +321,7 @@ declare const __VLS_base: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Com
     "update:loadDelay": (value: number | undefined) => any;
     "update:loaderStrategy": (value: AgentLoaderStrategy | undefined) => any;
     "update:fileUploadEnabled": (value: boolean) => any;
+    "update:toolWorkingSetMode": (value: AgentToolWorkingSetMode) => any;
     "update:voiceEnabled": (value: boolean) => any;
     "update:voiceMaxSessionSeconds": (value: number) => any;
     "update:voiceId": (value: string | undefined) => any;
@@ -558,6 +560,7 @@ declare const __VLS_base: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, Com
     "onUpdate:loadDelay"?: ((value: number | undefined) => any) | undefined;
     "onUpdate:loaderStrategy"?: ((value: AgentLoaderStrategy | undefined) => any) | undefined;
     "onUpdate:fileUploadEnabled"?: ((value: boolean) => any) | undefined;
+    "onUpdate:toolWorkingSetMode"?: ((value: AgentToolWorkingSetMode) => any) | undefined;
     "onUpdate:voiceEnabled"?: ((value: boolean) => any) | undefined;
     "onUpdate:voiceMaxSessionSeconds"?: ((value: number) => any) | undefined;
     "onUpdate:voiceId"?: ((value: string | undefined) => any) | undefined;

package/dist-vue/packages/components/src/chat/PkMessageParts.d.ts

@@ -14,21 +14,21 @@ interface SubAgentSlotPart {
 type __VLS_Props = {
     message: UIChatMessage;
 };
-declare var __VLS_107: {
+declare var __VLS_112: {
     part: SubAgentSlotPart;
-}, __VLS_110: string, __VLS_111: {
+}, __VLS_115: string, __VLS_116: {
     part: {
         type: `tool-${string}`;
     } & UIToolInvocation<UITool>;
-}, __VLS_119: {
+}, __VLS_124: {
     part: TextUIPart | ReasoningUIPart;
 };
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_110>]?: (props: typeof __VLS_111) => any;
+    [K in NonNullable<typeof __VLS_115>]?: (props: typeof __VLS_116) => any;
 } & {
-    subagent?: (props: typeof __VLS_107) => any;
+    subagent?: (props: typeof __VLS_112) => any;
 } & {
-    text?: (props: typeof __VLS_119) => any;
+    text?: (props: typeof __VLS_124) => any;
 };
 declare const __VLS_base: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist-vue/packages/components/src/chat/PkToolSelection.d.ts

@@ -0,0 +1,8 @@
+import { UIChatMessage } from '../../../models/src';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    message: UIChatMessage;
+};
+declare const __VLS_export: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist-vue/packages/composable/src/chatbot/useChatbotStore.d.ts

@@ -1,5 +1,5 @@
 import { Chat } from '@ai-sdk/vue';
-import { ChatMessageActions, UIChatMessage, AgentLoaderStrategy, StoragePolicy, AgentSearchMode, AgentBuiltInTool, WebSearchProvider, PlatformType, BlockedReasonCode, ConversationAnalysisTrigger, Sentiment, SentimentTrend, UserTone, AbuseCategory, LlmIssueCategory, UserEngagement, AbuseConfidence } from '../../../models/src';
+import { ChatMessageActions, UIChatMessage, AgentLoaderStrategy, StoragePolicy, AgentSearchMode, AgentBuiltInTool, WebSearchProvider, PlatformType, ToolGroupKind, BlockedReasonCode, ConversationAnalysisTrigger, Sentiment, SentimentTrend, UserTone, AbuseCategory, LlmIssueCategory, UserEngagement, AbuseConfidence } from '../../../models/src';
 import { ChatbotFile } from './api';
 import { PendingAttachment } from './types';
 import { Store } from 'pinia';
@@ -612,6 +612,27 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 cachedTokens?: number | undefined;
                 trafficType?: string | undefined;
                 transport?: string | undefined;
+                toolCatalogue?: {
+                    fingerprint: string;
+                    groups: {
+                        id: string;
+                        kind: ToolGroupKind;
+                        name: string;
+                        keys: string[];
+                    }[];
+                    workingSet?: {
+                        mode: "shadow" | "active";
+                        selected: string[];
+                        seeded: string[];
+                        probabilities: Record<string, number>;
+                        latencyMs: number;
+                        budgetMs: number;
+                        threshold: number;
+                        cost?: number | undefined;
+                        inputTokens?: number | undefined;
+                        failed?: boolean | undefined;
+                    } | undefined;
+                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -1095,6 +1116,27 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 cachedTokens?: number | undefined;
                 trafficType?: string | undefined;
                 transport?: string | undefined;
+                toolCatalogue?: {
+                    fingerprint: string;
+                    groups: {
+                        id: string;
+                        kind: ToolGroupKind;
+                        name: string;
+                        keys: string[];
+                    }[];
+                    workingSet?: {
+                        mode: "shadow" | "active";
+                        selected: string[];
+                        seeded: string[];
+                        probabilities: Record<string, number>;
+                        latencyMs: number;
+                        budgetMs: number;
+                        threshold: number;
+                        cost?: number | undefined;
+                        inputTokens?: number | undefined;
+                        failed?: boolean | undefined;
+                    } | undefined;
+                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -2276,6 +2318,27 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 cachedTokens?: number | undefined;
                 trafficType?: string | undefined;
                 transport?: string | undefined;
+                toolCatalogue?: {
+                    fingerprint: string;
+                    groups: {
+                        id: string;
+                        kind: ToolGroupKind;
+                        name: string;
+                        keys: string[];
+                    }[];
+                    workingSet?: {
+                        mode: "shadow" | "active";
+                        selected: string[];
+                        seeded: string[];
+                        probabilities: Record<string, number>;
+                        latencyMs: number;
+                        budgetMs: number;
+                        threshold: number;
+                        cost?: number | undefined;
+                        inputTokens?: number | undefined;
+                        failed?: boolean | undefined;
+                    } | undefined;
+                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -2759,6 +2822,27 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 cachedTokens?: number | undefined;
                 trafficType?: string | undefined;
                 transport?: string | undefined;
+                toolCatalogue?: {
+                    fingerprint: string;
+                    groups: {
+                        id: string;
+                        kind: ToolGroupKind;
+                        name: string;
+                        keys: string[];
+                    }[];
+                    workingSet?: {
+                        mode: "shadow" | "active";
+                        selected: string[];
+                        seeded: string[];
+                        probabilities: Record<string, number>;
+                        latencyMs: number;
+                        budgetMs: number;
+                        threshold: number;
+                        cost?: number | undefined;
+                        inputTokens?: number | undefined;
+                        failed?: boolean | undefined;
+                    } | undefined;
+                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -3940,6 +4024,27 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 cachedTokens?: number | undefined;
                 trafficType?: string | undefined;
                 transport?: string | undefined;
+                toolCatalogue?: {
+                    fingerprint: string;
+                    groups: {
+                        id: string;
+                        kind: ToolGroupKind;
+                        name: string;
+                        keys: string[];
+                    }[];
+                    workingSet?: {
+                        mode: "shadow" | "active";
+                        selected: string[];
+                        seeded: string[];
+                        probabilities: Record<string, number>;
+                        latencyMs: number;
+                        budgetMs: number;
+                        threshold: number;
+                        cost?: number | undefined;
+                        inputTokens?: number | undefined;
+                        failed?: boolean | undefined;
+                    } | undefined;
+                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";
@@ -4423,6 +4528,27 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 cachedTokens?: number | undefined;
                 trafficType?: string | undefined;
                 transport?: string | undefined;
+                toolCatalogue?: {
+                    fingerprint: string;
+                    groups: {
+                        id: string;
+                        kind: ToolGroupKind;
+                        name: string;
+                        keys: string[];
+                    }[];
+                    workingSet?: {
+                        mode: "shadow" | "active";
+                        selected: string[];
+                        seeded: string[];
+                        probabilities: Record<string, number>;
+                        latencyMs: number;
+                        budgetMs: number;
+                        threshold: number;
+                        cost?: number | undefined;
+                        inputTokens?: number | undefined;
+                        failed?: boolean | undefined;
+                    } | undefined;
+                } | undefined;
             } | undefined;
             parts: ({
                 type: "text";

package/dist-vue/packages/models/src/schema/Agent.d.ts

@@ -357,6 +357,12 @@ export declare const mcpToolKey: (toolName: string) => string;
 export declare const apiToolKey: (toolName: string) => string;
 /** Tool-set key of a sub-agent, from its camel-cased name. */
 export declare const subAgentToolKey: (subAgentName: string) => string;
+/**
+ * The tool that brings back a group the working set hid (spec
+ * tool-catalogue-working-set, F4). Not a built-in the agent switches: it
+ * exists exactly when the working set is active and hid something.
+ */
+export declare const ENABLE_TOOLS_TOOL = "enableTools";
 /**
  * Returns true if the tool can be put behind the user-approval gate
  * (`settings.tools.approval.tools`, see docs/specs/tool-approval-interface.md).
@@ -1103,6 +1109,29 @@ export declare const AgentOpenAiApiSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type AgentOpenAiApi = z.infer<typeof AgentOpenAiApiSchema>;
+/**
+ * Working set of the tool catalogue (spec tool-catalogue-working-set, F4):
+ * before the first step an evaluation model decides which MCP servers, API
+ * tools and sub-agents the turn needs, and the model sees only those plus a
+ * tool to enable the others.
+ * - `off`: every tool is exposed, as before;
+ * - `shadow`: the decision is taken and recorded on the message, every tool
+ *   is still exposed, so it can be read against the tools the model called;
+ * - `active`: the decision is applied.
+ *
+ * The evaluation model is served only by the gateway: the setting needs the
+ * organization's `gateway` feature, and an agent on the organization's own
+ * endpoint keeps it off.
+ */
+export declare enum AgentToolWorkingSetMode {
+    Off = "off",
+    Shadow = "shadow",
+    Active = "active"
+}
+export declare const AgentToolWorkingSetSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+}, z.core.$strip>;
+export type AgentToolWorkingSet = z.infer<typeof AgentToolWorkingSetSchema>;
 /**
  * Shortest first-token deadline the provider actually honours. Below it the
  * turn does not fall back on their model, it fails outright with "LLM Cascade
@@ -1595,6 +1624,9 @@ export declare const AgentSettingsSchema: z.ZodObject<{
         providerSecretId: z.ZodOptional<z.ZodString>;
         providerApiKeyId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type AgentSettings = z.infer<typeof AgentSettingsSchema>;
 export declare const AgentSecuritySchema: z.ZodObject<{
@@ -1987,6 +2019,9 @@ export declare const AgentDtoSchema: z.ZodObject<{
             providerSecretId: z.ZodOptional<z.ZodString>;
             providerApiKeyId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     security: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         rateLimits: z.ZodObject<{
@@ -2380,6 +2415,9 @@ export declare const AgentSchema: z.ZodLazy<z.ZodObject<{
             providerSecretId: z.ZodOptional<z.ZodString>;
             providerApiKeyId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     security: z.ZodNullable<z.ZodObject<{
         rateLimits: z.ZodObject<{

package/dist-vue/packages/models/src/schema/Chat.d.ts

@@ -334,6 +334,112 @@ export type ChatMessageActions = 'show-info' | 'revise' | 'regenerate' | 'upvote
 export type Chat = z.infer<typeof ChatSchema>;
 export type ChatsQuerystring = z.infer<typeof ChatsQuerystringSchema>;
 export type UIChatMessageDeviceContext = DeviceContext;
+/** Kinds of tool group the working set decides on, one group per MCP server. */
+export type ToolGroupKind = 'mcp' | 'api' | 'subagent';
+/**
+ * What the working set decided for a turn (spec tool-catalogue-working-set,
+ * F4). Group ids are those of {@link ToolCatalogueRecord}; the groups the model
+ * enabled later in the turn are read from its `enableTools` calls.
+ */
+export type ToolWorkingSetRecord = {
+    /** `shadow` recorded the decision and exposed everything, `active` applied it. */
+    mode: 'shadow' | 'active';
+    /** Groups exposed from the first step: the judged ones and the seed. */
+    selected: string[];
+    /** Groups the conversation seeded, exposed whatever the judgment. */
+    seeded: string[];
+    /** Probability the evaluation model gave each judged group, two decimals. */
+    probabilities: Record<string, number>;
+    latencyMs: number;
+    /**
+     * Time the evaluation was given: short in active mode, where the turn
+     * waits for it, longer in shadow mode, where it runs alongside.
+     */
+    budgetMs: number;
+    /** Probability from which a judged group is exposed. */
+    threshold: number;
+    /**
+     * What the evaluation cost in USD, the amount charged to the organization.
+     * Absent when it failed: nothing is charged then.
+     */
+    cost?: number;
+    inputTokens?: number;
+    /**
+     * The evaluation answered with an error or not within the budget, and
+     * every group stayed exposed.
+     */
+    failed?: boolean;
+};
+/**
+ * The part of a turn's tool catalogue the working set acts on (spec
+ * tool-catalogue-working-set, F2): which MCP servers, API tools and sub-agents
+ * were eligible, identified by id and not by the public keys, which collide
+ * across servers. Enough to make a measurement repeatable without storing the
+ * schemas.
+ */
+export type ToolCatalogueRecord = {
+    /** Short hash of the eligible keys and their groups: two turns with the same set agree on it. */
+    fingerprint: string;
+    groups: Array<{
+        id: string;
+        kind: ToolGroupKind;
+        name: string;
+        /**
+         * Keys of the group offered this turn: what attributes a call in the
+         * message to its group, since a key names a different server's tool
+         * in another turn.
+         */
+        keys: string[];
+    }>;
+    workingSet?: ToolWorkingSetRecord;
+};
+/** One group of a turn's catalogue, read against what the turn did with it. */
+export type ToolSelectionGroup = {
+    id: string;
+    kind: ToolGroupKind;
+    name: string;
+    tools: number;
+    /** Absent when the evaluation failed. */
+    probability?: number;
+    /** Exposed from the first step in active mode, or would have been in shadow mode. */
+    selected: boolean;
+    seeded: boolean;
+    /**
+     * Brought back during the turn, by `enableTools` or by a direct call to
+     * one of its tools that the model was refused as unavailable.
+     */
+    enabled: boolean;
+    /**
+     * The model called one of its tools, whatever came of the call (an error,
+     * a denied approval): the turn needed the group.
+     */
+    used: boolean;
+};
+export type ToolSelectionSummary = {
+    decision: ToolWorkingSetRecord;
+    /** Most probable first, then by name. */
+    groups: ToolSelectionGroup[];
+    /**
+     * Groups the turn used that the decision left out. In active mode the
+     * model had to bring each one back, in shadow mode it would have had to:
+     * the working set's miss, the figure F3 of the spec counts.
+     */
+    missed: number;
+};
+/**
+ * The working set's decision on a turn next to what the turn did: which
+ * groups it exposed, which the model brought back and which it used. Read
+ * from the stored answer, whose metadata carries the record and whose parts
+ * carry the calls, the way the backend read them during the turn: a call
+ * counts under the name the repair would give it, and an `enableTools` call
+ * only once it ran. Undefined when the working set did not decide.
+ */
+export declare function summarizeToolSelection(message: {
+    parts?: ReadonlyArray<unknown>;
+    metadata?: {
+        toolCatalogue?: ToolCatalogueRecord;
+    };
+}): ToolSelectionSummary | undefined;
 export type UIChatMessageMetadata = {
     /** Unix timestamp (ms) when the stream started */
     createdAt?: number;
@@ -378,10 +484,24 @@ export type UIChatMessageMetadata = {
      * `openai-api` an API turn. Absent on plain web messages.
      */
     transport?: string;
+    /**
+     * The MCP servers, API tools and sub-agents this turn could use, and the
+     * working set's decision on them. Absent when the agent has none. Kept
+     * from a public reader: streamed only to the organization's own audiences
+     * (on the closing finish), and removed from whatever else leaves the
+     * organization ({@link withoutToolCatalogue}).
+     */
+    toolCatalogue?: ToolCatalogueRecord;
 };
 export type UIChatMessage = UIMessage & {
     metadata?: UIChatMessageMetadata;
 };
+/**
+ * The history without the tool catalogue records, for a reader outside the
+ * organization (a public chat read, the data export): a record names every
+ * group the agent has, used or not.
+ */
+export declare function withoutToolCatalogue(messages: UIChatMessage[]): UIChatMessage[];
 /**
  * States in which a tool invocation part waits for nothing more.
  *

package/dist-vue/packages/models/src/schema/ReasoningChat.d.ts

@@ -1,6 +1,6 @@
 import { UIChatMessage, BlockedReasonCode } from './Chat';
 import { LanguageModelUsage } from 'ai';
-import { AgentStatus, AgentVisibility, AgentSearchMode, AgentLoaderStrategy, AgentBuiltInTool, WebSearchProvider, AgentChannel, AgentType } from './Agent';
+import { AgentStatus, AgentVisibility, AgentSearchMode, AgentLoaderStrategy, AgentBuiltInTool, WebSearchProvider, AgentChannel, AgentToolWorkingSetMode, AgentType } from './Agent';
 import { StoragePolicy } from './Media';
 import { ConversationAnalysisTrigger, Sentiment, SentimentTrend, UserTone, AbuseCategory, AbuseConfidence, LlmIssueCategory, UserEngagement } from './ConversationAnalysis';
 import * as z from 'zod';
@@ -397,6 +397,9 @@ export declare const ReasoningChatSchema: z.ZodObject<{
                 providerSecretId: z.ZodOptional<z.ZodString>;
                 providerApiKeyId: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>;
+            toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         security: z.ZodNullable<z.ZodObject<{
             rateLimits: z.ZodObject<{
@@ -841,6 +844,9 @@ export declare const ReasoningChatSchema: z.ZodObject<{
                     providerSecretId: z.ZodOptional<z.ZodString>;
                     providerApiKeyId: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>>;
+                toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>;
             security: z.ZodNullable<z.ZodObject<{
                 rateLimits: z.ZodObject<{

package/dist-vue/packages/models/src/schema/StreamError.d.ts

@@ -14,3 +14,16 @@ export declare function parseStreamError(message: string | undefined): {
     payload: StreamErrorPayload;
 } | undefined;
 export declare function matchesStreamErrorCode(message: string | undefined, code: string): boolean;
+/**
+ * The SDK refusing a call to a tool the step did not offer
+ * (AI_NoSuchToolError), capturing the tool name. One pattern for the backend,
+ * which reads the refusal from the step, and for the message detail, which
+ * reads it from the stored part (`summarizeToolSelection`).
+ */
+export declare const UNAVAILABLE_TOOL_ERROR_PATTERN: RegExp;
+/**
+ * The text a refused call is stored and streamed with: the SDK's own first
+ * sentence, without its list of the step's tools, so it still matches the
+ * pattern above.
+ */
+export declare const unavailableToolErrorText: (toolName: string) => string;

package/dist-vue/packages/models/src/schema/SubAgent.d.ts

@@ -1,4 +1,4 @@
-import { AgentStatus, AgentVisibility, AgentSearchMode, AgentLoaderStrategy, AgentBuiltInTool, WebSearchProvider, AgentChannel, AgentType } from './Agent';
+import { AgentStatus, AgentVisibility, AgentSearchMode, AgentLoaderStrategy, AgentBuiltInTool, WebSearchProvider, AgentChannel, AgentToolWorkingSetMode, AgentType } from './Agent';
 import { StoragePolicy } from './Media';
 import * as z from 'zod';
 export declare enum SubAgentStatus {
@@ -397,6 +397,9 @@ export declare const SubAgentSchema: z.ZodObject<{
                 providerSecretId: z.ZodOptional<z.ZodString>;
                 providerApiKeyId: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>;
+            toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         security: z.ZodNullable<z.ZodObject<{
             rateLimits: z.ZodObject<{
@@ -799,6 +802,9 @@ export declare const SubAgentSchema: z.ZodObject<{
                 providerSecretId: z.ZodOptional<z.ZodString>;
                 providerApiKeyId: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>;
+            toolWorkingSet: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodEnum<typeof AgentToolWorkingSetMode>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         security: z.ZodNullable<z.ZodObject<{
             rateLimits: z.ZodObject<{

package/dist-vue/packages/models/src/schema/constants.d.ts

@@ -51,6 +51,15 @@ export declare enum EmbeddingModel {
     geminiEmbedding2 = "google/gemini-embedding-2"
 }
 export declare const EMBED_MODEL = EmbeddingModel.geminiEmbedding2;
+/**
+ * Model that answers typed questions (yes/no, choice, score) with calibrated
+ * probabilities instead of text, through the gateway's `experimental_evaluate`
+ * (TypeSafe Jev). Out of the catalog like the embeddings: it decides for the
+ * platform, it never answers the user. Its gateway listing reports no ZDR,
+ * yet a ZDR request is served, routed to TypeSafe alone (measured
+ * 2026-09-28, scripts/spikeJevEvaluation.ts).
+ */
+export declare const EVALUATION_MODEL = "typesafe-ai/jev";
 /**
  * Supported languages for documents and revised answers
  */