@8wave/ai-elements 0.111.0 → 0.112.0-beta.10

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: "Mode",
 		deprecated: "Deprecated",
 		whatsapp: "WhatsApp",
 		teams: "Microsoft Teams",
@@ -499,6 +501,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 +540,22 @@ var e = {
 		expired: "This request is no longer answerable: the action was not performed.",
 		prompt: "Your confirmation is needed to continue:"
 	},
+	toolSelection: {
+		exposed: "Groups exposed to the model: probability {threshold} or higher, or used earlier",
+		latency: "Evaluation time, limit {budget} ms",
+		cost: "Cost charged to the organization: {cost}",
+		notCharged: "Not charged",
+		inputTokens: "Input tokens",
+		title: "Tool selection",
+		failed: "Failed",
+		leadFailed: "The evaluation failed or did not answer within {budget} ms: every group stayed exposed.",
+		tools: "{n} tool | {n} tools",
+		missed: "Missed",
+		used: "Used",
+		enabled: "Brought back",
+		seeded: "Used earlier",
+		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 +797,8 @@ var e = {
 		fileUploadMaxFilesPerMessage: "File massimi per messaggio",
 		fileUploadMaxFilesPerChat: "File massimi per chat",
 		webSearch: "Ricerca web",
+		toolWorkingSet: "Selezione dei tool",
+		toolWorkingSetMode: "Modalità",
 		deprecated: "Deprecato",
 		whatsapp: "WhatsApp",
 		teams: "Microsoft Teams",
@@ -1049,6 +1070,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 +1109,22 @@ var e = {
 		expired: "Questa richiesta non è più confermabile: l'azione non è stata eseguita.",
 		prompt: "Per continuare serve la tua conferma:"
 	},
+	toolSelection: {
+		exposed: "Gruppi esposti al modello: probabilità da {threshold} in su, o usati prima",
+		latency: "Tempo della valutazione, limite {budget} ms",
+		cost: "Costo addebitato all’organizzazione: {cost}",
+		notCharged: "Non addebitata",
+		inputTokens: "Token in ingresso",
+		title: "Selezione dei tool",
+		failed: "Non riuscita",
+		leadFailed: "La valutazione non è riuscita o non ha risposto entro {budget} ms: tutti i gruppi sono rimasti esposti.",
+		tools: "{n} tool | {n} tool",
+		missed: "Mancato",
+		used: "Usato",
+		enabled: "Riattivato",
+		seeded: "Usato prima",
+		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_766: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_749) => any;
+    default?: (props: typeof __VLS_766) => 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/PkLanguageModelCombobox.d.ts

@@ -40,6 +40,13 @@ type __VLS_Props = {
      * valid price reference.
      */
     offerDisabled?: boolean;
+    /**
+     * What the chosen model has to read, as the gateway listing spells it
+     * (`pdf`, `image`): a model whose listing says it does not is not
+     * offered. One the listing knows nothing about (an endpoint model
+     * with no match) stays, and the call says whether it reads it.
+     */
+    inputModality?: string;
     /**
      * Declared so it cannot fall through, never read. This component owns
      * its option list: it builds it from the catalog, filters it by the

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/components/src/types.d.ts

@@ -1,4 +1,4 @@
-import { Ref } from 'vue';
+import { Ref, VNode } from 'vue';
 export type TableColumnRecord<T = Record<string, unknown>> = {
     name: string;
     field?: string;
@@ -8,7 +8,12 @@ export type TableColumnRecord<T = Record<string, unknown>> = {
     classTh?: string;
     classTd?: string;
     wrapperClass?: string;
-    render?: (row: T, index?: number) => unknown;
+    /**
+     * The cell content, rendered through `<component :is>`: a bare string
+     * would be read as a tag name, so return a vnode (`h('span', text)`), or
+     * `null` or `undefined` for an empty cell.
+     */
+    render?: (row: T, index?: number) => VNode | null | undefined;
     hidden?: boolean | Ref<boolean | undefined>;
 };
 export type TableColumn<T = Record<string, unknown>> = TableColumnRecord<T> | string;

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";
@@ -637,6 +658,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -805,6 +827,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -1095,6 +1118,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";
@@ -1120,6 +1164,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -1288,6 +1333,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -2276,6 +2322,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";
@@ -2301,6 +2368,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -2469,6 +2537,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -2759,6 +2828,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";
@@ -2784,6 +2874,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -2952,6 +3043,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -3940,6 +4032,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";
@@ -3965,6 +4078,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -4133,6 +4247,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -4423,6 +4538,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";
@@ -4448,6 +4584,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;
@@ -4616,6 +4753,7 @@ export declare function useChatbotStore(agentId: string): Store<`chatbot-${strin
                 providerExecuted?: boolean | undefined;
                 state: "input-streaming";
                 input?: unknown;
+                rawInput?: string | undefined;
                 output?: never | undefined;
                 errorText?: never | undefined;
                 callProviderMetadata?: ProviderMetadata | undefined;

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.
  *