@8wave/ai-elements 0.100.0 → 0.101.0-beta.1

package/dist-vue/locales.js

@@ -364,6 +364,7 @@ var e = {
 			app: "The agent is accessible via the dedicated public page.",
 			widget: "The agent can be embedded in websites via embed script."
 		},
+		reasoningDefault: "Platform default, applied until you choose a different value.",
 		includeThoughts: "Streams the model's thoughts to the client along with the response.",
 		reasoningNotSupported: "Reasoning is not supported for the selected provider.",
 		webSearchEnabled: "Allow the agent to search the web during conversations.",
@@ -851,6 +852,7 @@ var e = {
 			app: "L'agente è accessibile tramite la pagina pubblica dedicata.",
 			widget: "L'agente è incorporabile nei siti web tramite embed script."
 		},
+		reasoningDefault: "Valore predefinito della piattaforma, si applica finché non scegli un valore diverso.",
 		includeThoughts: "Invia i pensieri del modello al client insieme alla risposta.",
 		reasoningNotSupported: "Il reasoning non è supportato per il provider selezionato.",
 		webSearchEnabled: "Permetti all'agente di cercare informazioni sul web durante le conversazioni.",

package/dist-vue/packages/auth/src/index.d.ts

@@ -1081,8 +1081,8 @@ export declare const config: {
                     $Infer: {
                         body: {
                             permissions: {
-                                readonly user?: ("create" | "update" | "delete" | "impersonate" | "ban" | "get" | "list" | "set-role" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
-                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                readonly user?: ("list" | "create" | "update" | "delete" | "impersonate" | "ban" | "get" | "set-role" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
+                                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
                             };
                         } & {
                             userId?: string | undefined;
@@ -2793,8 +2793,8 @@ export declare const auth: Auth<{
                     $Infer: {
                         body: {
                             permissions: {
-                                readonly user?: ("create" | "update" | "delete" | "impersonate" | "ban" | "get" | "list" | "set-role" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
-                                readonly session?: ("delete" | "list" | "revoke")[] | undefined;
+                                readonly user?: ("list" | "create" | "update" | "delete" | "impersonate" | "ban" | "get" | "set-role" | "impersonate-admins" | "set-password" | "set-email")[] | undefined;
+                                readonly session?: ("list" | "delete" | "revoke")[] | undefined;
                             };
                         } & {
                             userId?: string | undefined;

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

@@ -136,15 +136,60 @@ export declare const AgentReasoningSchema: z.ZodOptional<z.ZodCodec<z.ZodUnknown
     }, z.core.$strip>>;
 }, z.core.$strip>>>;
 export type AgentReasoning = z.infer<typeof AgentReasoningSchema>;
+/** Provider an agent model belongs to, from its `provider/model` id. */
+export declare function modelProvider(model: string): string;
+/**
+ * Explicit reasoning configuration for an agent that has none for the provider
+ * it is running on.
+ *
+ * Without it the request carries no reasoning directive at all and the provider
+ * applies its own default, which on the current families means thinking is ON:
+ * measured on the turn-latency bench, **each reasoning token costs about 8ms of
+ * time to first token** (~125 tok/s of decode), so a default nobody chose is
+ * worth seconds per turn. The lowest tier that still reasons is the deliberate
+ * choice: tool selection and the presentation contract both degrade when a chat
+ * agent stops deliberating entirely, and that is a worse trade than the latency
+ * it would buy.
+ *
+ * DeepSeek is deliberately absent: its thinking is model-intrinsic (there are
+ * `-thinking` model ids) and a blanket directive there could contradict the
+ * model itself. Agents on DeepSeek keep the provider default until someone
+ * measures that family.
+ */
+export declare const DEFAULT_REASONING_BY_PROVIDER: NonNullable<AgentReasoning>;
+/**
+ * What will actually reach `provider`: the agent's own block when it configures
+ * anything, otherwise the platform default.
+ *
+ * Shared on purpose. The runtime reaches it through
+ * {@link resolveEffectiveReasoning}, and the agent form calls it directly to
+ * display the value: a form that showed an empty level while the turn sends
+ * `low` would describe a behaviour that does not exist.
+ *
+ * Returns the stored block **by identity** when there is one, so a caller can
+ * tell a configured value from a default with `===`.
+ */
+export declare function effectiveProviderReasoning<P extends keyof NonNullable<AgentReasoning>>(provider: P, reasoning: AgentReasoning | null | undefined): NonNullable<AgentReasoning>[P];
+/**
+ * The reasoning configuration that will actually reach the provider: the
+ * agent's own when it has one for this model's provider, otherwise the explicit
+ * default above.
+ *
+ * Cross-provider is the case that motivated it: an agent configured for OpenAI
+ * and switched to Gemini has `reasoning.openai` set and `reasoning.google`
+ * empty, so before this it silently inherited Gemini's default.
+ */
+export declare function resolveEffectiveReasoning(model: string, reasoning: AgentReasoning | null | undefined): AgentReasoning;
 /**
  * Whether reasoning is effectively enabled for the given model.
  *
- * Mirrors the runtime semantics of `getReasoningOptions` (backend):
- * only the provider config matching the model prefix is considered.
- * Note: for Anthropic with `display: 'omitted'` reasoning runs but no
- * reasoning parts are streamed to the client.
+ * Mirrors the runtime semantics of `getReasoningOptions` (backend): only the
+ * provider config matching the model prefix is considered, and an agent with no
+ * config for that provider gets {@link DEFAULT_REASONING_BY_PROVIDER}, exactly
+ * as the turn does. Note: for Anthropic with `display: 'omitted'` reasoning runs
+ * but no reasoning parts are streamed to the client.
  */
-export declare function isReasoningEnabled(model: string, reasoning: AgentReasoning | null | undefined): boolean;
+export declare function isReasoningEnabled(model: string, agentReasoning: AgentReasoning | null | undefined): boolean;
 export declare enum AgentBuiltInTool {
     Geocode = "geocode",
     GetWeather = "getWeather",
@@ -212,6 +257,51 @@ export declare function isPresentationTool(toolName: string): boolean;
 export declare const PLATFORM_RENDERED_TOOLS: Set<string>;
 /** True if the tool renders natively on Teams/WhatsApp (not just web). */
 export declare function isPlatformRenderedTool(toolName: string): boolean;
+/**
+ * Transport a turn arrived through. Recorded on the chat metadata and on the
+ * latency histograms, and it is what decides {@link ClientToolSurface}: the
+ * transport is a fact of the request, not a per-agent setting.
+ */
+export declare enum ChatTransport {
+    /** Web chat and embeddable widget: the reference surface. */
+    Web = "web",
+    /** Messaging channels (Teams, WhatsApp) through the platform runner. */
+    Platform = "platform",
+    /** OpenAI-compatible REST surface: automations, SDKs, voice agents. */
+    OpenAiApi = "openai-api"
+}
+/**
+ * What the caller of a turn can actually DO with a client-side tool.
+ *
+ * Client tools have no `execute`: something on the other side has to render the
+ * widget and post the result back. Offering one to a caller that cannot is not
+ * a missing nicety, it is a defect with a measured cost: the model spends a
+ * full round trip calling it (`showSuggestedReply` on every sample of the
+ * turn-latency baseline), the call is never answered, and its guidance sits in
+ * the system prompt of every turn.
+ */
+export declare enum ClientToolSurface {
+    /** Full client runtime: every enabled client tool renders. */
+    Web = "web",
+    /** Renders only {@link PLATFORM_RENDERED_TOOLS}; the rest never resolve. */
+    Platform = "platform",
+    /** No client runtime at all: the caller consumes text (and tool results). */
+    Headless = "headless"
+}
+/** Single availability rule for a client tool, shared by tool set and prompt. */
+export declare function supportsClientTool(surface: ClientToolSurface, toolName: string): boolean;
+/**
+ * Surface of a transport. Unknown transports are treated as Web, which is the
+ * historical behaviour: a new caller has to opt into being headless, so adding
+ * one can never silently strip the widgets from an existing channel.
+ */
+export declare function clientToolSurfaceOf(transport: ChatTransport | string | undefined): ClientToolSurface;
+/**
+ * True when nobody is watching the response render: the transport delivers text
+ * to a program (or to a speech synthesizer), so anything that paces the stream
+ * for the human eye is pure added latency.
+ */
+export declare function isHeadlessTransport(transport: ChatTransport | string | undefined): boolean;
 export declare const AgentFormSettingsSchema: z.ZodObject<{
     maxSteps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     maxOptionsPerStep: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -724,6 +814,16 @@ export declare const AgentGatewayOptionsSchema: z.ZodObject<{
     providerTimeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type AgentGatewayOptions = z.infer<typeof AgentGatewayOptionsSchema>;
+/**
+ * Exposure of the agent through the OpenAI-compatible surface
+ * (`/api/openai/v1`), where any third-party client that speaks chat
+ * completions can consume it as if it were a model. Off by default: turning it
+ * on makes the agent reachable with an organization API key.
+ */
+export declare const AgentOpenAiApiSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AgentOpenAiApi = z.infer<typeof AgentOpenAiApiSchema>;
 export declare const AgentSettingsSchema: z.ZodObject<{
     model: z.ZodObject<{
         prompt: z.ZodOptional<z.ZodString>;
@@ -1022,6 +1122,9 @@ export declare const AgentSettingsSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<typeof AgentChannel>>>>;
     externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type AgentSettings = z.infer<typeof AgentSettingsSchema>;
 export declare const AgentSecuritySchema: z.ZodObject<{
@@ -1342,6 +1445,9 @@ export declare const AgentDtoSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<typeof AgentChannel>>>>;
         externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     security: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         rateLimits: z.ZodObject<{
@@ -1663,6 +1769,9 @@ export declare const AgentSchema: z.ZodLazy<z.ZodObject<{
         }, z.core.$strip>>>;
         channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<typeof AgentChannel>>>>;
         externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     security: z.ZodNullable<z.ZodObject<{
         rateLimits: z.ZodObject<{

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

@@ -233,8 +233,15 @@ export declare enum BlockedReasonCode {
 }
 export type ChatMetadata = {
     ipAddress: string;
+    /** HTTP `Origin` of the request, empty for a server-to-server caller. */
     origin: string;
     userAgent: string;
+    /**
+     * Non-default transport the conversation arrived through (for example
+     * `openai-api`), so cost and usage reports can isolate it. Absent for the
+     * web and widget chat.
+     */
+    transport?: string;
 };
 export type ChatMessageActions = 'show-info' | 'revise' | 'regenerate' | 'upvote' | 'downvote' | 'feedback';
 export type Chat = z.infer<typeof ChatSchema>;

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

@@ -0,0 +1,192 @@
+import * as z from 'zod';
+/**
+ * Subset of the OpenAI chat completions protocol spoken by the agent-facing
+ * compatibility surface (`/api/openai/v1`).
+ *
+ * The request schemas are deliberately loose: a third-party client sends the
+ * fields its own SDK produces, and rejecting an otherwise legal OpenAI request
+ * because of a field we do not use would break integrations for no gain.
+ * Unknown fields are therefore accepted and ignored.
+ */
+export declare enum OpenAiCompatRole {
+    System = "system",
+    Developer = "developer",
+    User = "user",
+    Assistant = "assistant",
+    Tool = "tool"
+}
+/** Reasons reported back to the caller, in OpenAI's vocabulary. */
+export declare enum OpenAiCompatFinishReason {
+    Stop = "stop",
+    Length = "length",
+    ToolCalls = "tool_calls",
+    ContentFilter = "content_filter"
+}
+/** Error codes emitted by the compatibility surface. */
+export declare enum OpenAiCompatErrorCode {
+    InvalidApiKey = "invalid_api_key",
+    ModelNotFound = "model_not_found",
+    RateLimitExceeded = "rate_limit_exceeded",
+    InsufficientQuota = "insufficient_quota",
+    InvalidRequestError = "invalid_request_error",
+    InternalError = "internal_error"
+}
+export declare const OPENAI_COMPAT_MODEL_OBJECT = "model";
+export declare const OPENAI_COMPAT_COMPLETION_OBJECT = "chat.completion";
+export declare const OPENAI_COMPAT_CHUNK_OBJECT = "chat.completion.chunk";
+export declare const OpenAiCompatContentPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image_url">;
+    image_url: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$strip>], "type">;
+export type OpenAiCompatContentPart = z.infer<typeof OpenAiCompatContentPartSchema>;
+export declare const OpenAiCompatMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<typeof OpenAiCompatRole>;
+    content: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image_url">;
+        image_url: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$strip>], "type">>]>>>;
+    name: z.ZodOptional<z.ZodString>;
+    tool_call_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type OpenAiCompatMessage = z.infer<typeof OpenAiCompatMessageSchema>;
+export declare const OpenAiCompatChatRequestSchema: z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<typeof OpenAiCompatRole>;
+        content: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image_url">;
+            image_url: z.ZodObject<{
+                url: z.ZodString;
+            }, z.core.$loose>;
+        }, z.core.$strip>], "type">>]>>>;
+        name: z.ZodOptional<z.ZodString>;
+        tool_call_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+    stream_options: z.ZodOptional<z.ZodObject<{
+        include_usage: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    elevenlabs_extra_body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    user: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodUnknown>;
+    tool_choice: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export type OpenAiCompatChatRequest = z.infer<typeof OpenAiCompatChatRequestSchema>;
+export declare const OpenAiCompatUsageSchema: z.ZodObject<{
+    prompt_tokens: z.ZodNumber;
+    completion_tokens: z.ZodNumber;
+    total_tokens: z.ZodNumber;
+}, z.core.$strip>;
+export type OpenAiCompatUsage = z.infer<typeof OpenAiCompatUsageSchema>;
+export declare const OpenAiCompatToolCallSchema: z.ZodObject<{
+    index: z.ZodOptional<z.ZodNumber>;
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodLiteral<"function">>;
+    function: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        arguments: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OpenAiCompatToolCall = z.infer<typeof OpenAiCompatToolCallSchema>;
+export declare const OpenAiCompatChunkSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"chat.completion.chunk">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        delta: z.ZodObject<{
+            role: z.ZodOptional<z.ZodLiteral<"assistant">>;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reasoning_content: z.ZodOptional<z.ZodString>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                index: z.ZodOptional<z.ZodNumber>;
+                id: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodLiteral<"function">>;
+                function: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    arguments: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        finish_reason: z.ZodNullable<z.ZodEnum<typeof OpenAiCompatFinishReason>>;
+    }, z.core.$strip>>;
+    usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type OpenAiCompatChunk = z.infer<typeof OpenAiCompatChunkSchema>;
+export declare const OpenAiCompatCompletionSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"chat.completion">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        message: z.ZodObject<{
+            role: z.ZodLiteral<"assistant">;
+            content: z.ZodNullable<z.ZodString>;
+            reasoning_content: z.ZodOptional<z.ZodString>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                index: z.ZodOptional<z.ZodNumber>;
+                id: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodLiteral<"function">>;
+                function: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    arguments: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        finish_reason: z.ZodNullable<z.ZodEnum<typeof OpenAiCompatFinishReason>>;
+    }, z.core.$strip>>;
+    usage: z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OpenAiCompatCompletion = z.infer<typeof OpenAiCompatCompletionSchema>;
+export declare const OpenAiCompatModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"model">;
+    created: z.ZodNumber;
+    owned_by: z.ZodString;
+    display_name: z.ZodString;
+}, z.core.$strip>;
+export type OpenAiCompatModel = z.infer<typeof OpenAiCompatModelSchema>;
+export declare const OpenAiCompatModelListSchema: z.ZodObject<{
+    object: z.ZodLiteral<"list">;
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"model">;
+        created: z.ZodNumber;
+        owned_by: z.ZodString;
+        display_name: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OpenAiCompatModelList = z.infer<typeof OpenAiCompatModelListSchema>;
+export declare const OpenAiCompatErrorSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        type: z.ZodString;
+        code: z.ZodEnum<typeof OpenAiCompatErrorCode>;
+        param: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OpenAiCompatError = z.infer<typeof OpenAiCompatErrorSchema>;

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

@@ -325,6 +325,9 @@ export declare const ReasoningChatSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum< AgentChannel>>>>;
             externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         security: z.ZodNullable<z.ZodObject<{
             rateLimits: z.ZodObject<{
@@ -697,6 +700,9 @@ export declare const ReasoningChatSchema: z.ZodObject<{
                 }, z.core.$strip>>>;
                 channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum< AgentChannel>>>>;
                 externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>;
             security: z.ZodNullable<z.ZodObject<{
                 rateLimits: z.ZodObject<{

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

@@ -325,6 +325,9 @@ export declare const SubAgentSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum< AgentChannel>>>>;
             externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         security: z.ZodNullable<z.ZodObject<{
             rateLimits: z.ZodObject<{
@@ -655,6 +658,9 @@ export declare const SubAgentSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             channels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum< AgentChannel>>>>;
             externalContextSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            openaiApi: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         security: z.ZodNullable<z.ZodObject<{
             rateLimits: z.ZodObject<{

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

@@ -0,0 +1,153 @@
+import * as z from 'zod';
+/**
+ * Shape of a turn timing record, shared by the backend tracker that produces it,
+ * the debug endpoint that serves it and the frontend page that renders it.
+ *
+ * It lives here because the three used to declare it independently and the
+ * response schema strips unknown keys: a field added to the tracker but not to
+ * the schema disappears from the API without any error, which is exactly how a
+ * new measurement ends up silently missing.
+ */
+/**
+ * Redis list holding the timing entries (newest first). Declared here, with the
+ * shape, so both the tracker that writes it and the operational scripts that
+ * read it use one name without dragging the backend DI container into a script.
+ */
+export declare const TIMING_REDIS_KEY = "debug:timing:logs";
+export declare const TimingPhasePosition: {
+    readonly Pre: "pre";
+    readonly Post: "post";
+};
+export type TimingPhasePosition = (typeof TimingPhasePosition)[keyof typeof TimingPhasePosition];
+export declare const TimingToolCallDetailSchema: z.ZodObject<{
+    toolCallId: z.ZodString;
+    name: z.ZodString;
+    args: z.ZodString;
+    result: z.ZodString;
+}, z.core.$strip>;
+export declare const TimingPhaseRecordSchema: z.ZodObject<{
+    label: z.ZodString;
+    durationMs: z.ZodNumber;
+    position: z.ZodEnum<{
+        pre: "pre";
+        post: "post";
+    }>;
+    startOffsetMs: z.ZodOptional<z.ZodNumber>;
+    endOffsetMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TimingStepRecordSchema: z.ZodObject<{
+    stepIndex: z.ZodNumber;
+    stepKind: z.ZodString;
+    durationMs: z.ZodNumber;
+    modelId: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    reasoningTokens: z.ZodNumber;
+    cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+    toolCalls: z.ZodArray<z.ZodString>;
+    toolCallDetails: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        toolCallId: z.ZodString;
+        name: z.ZodString;
+        args: z.ZodString;
+        result: z.ZodString;
+    }, z.core.$strip>>>;
+    text: z.ZodDefault<z.ZodString>;
+    tokenStreamMs: z.ZodOptional<z.ZodNumber>;
+    responseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Named instants on the turn timeline, as offsets from the timing origin (the
+ * request entering Fastify when the anchor hook ran, otherwise tracker
+ * construction). Recorded only when the turn reaches them.
+ */
+export declare const TimingMilestonesSchema: z.ZodObject<{
+    turnStarted: z.ZodOptional<z.ZodNumber>;
+    providerInvoked: z.ZodOptional<z.ZodNumber>;
+    providerFirstEvent: z.ZodOptional<z.ZodNumber>;
+    providerFirstTextDelta: z.ZodOptional<z.ZodNumber>;
+    responseFirstTextDelta: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Event-loop lag observed process-wide when the entry was written, in ms.
+ * Distinguishes "waiting on the network" from "blocking the thread", which is
+ * the difference between an I/O fix and a CPU fix.
+ */
+export declare const TimingEventLoopLagSchema: z.ZodObject<{
+    meanMs: z.ZodNumber;
+    p50Ms: z.ZodNumber;
+    p95Ms: z.ZodNumber;
+    maxMs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const TimingEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+        main: "main";
+        subagent: "subagent";
+    }>;
+    totalMs: z.ZodNumber;
+    requestTotalMs: z.ZodOptional<z.ZodNumber>;
+    steps: z.ZodArray<z.ZodObject<{
+        stepIndex: z.ZodNumber;
+        stepKind: z.ZodString;
+        durationMs: z.ZodNumber;
+        modelId: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+        toolCalls: z.ZodArray<z.ZodString>;
+        toolCallDetails: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            toolCallId: z.ZodString;
+            name: z.ZodString;
+            args: z.ZodString;
+            result: z.ZodString;
+        }, z.core.$strip>>>;
+        text: z.ZodDefault<z.ZodString>;
+        tokenStreamMs: z.ZodOptional<z.ZodNumber>;
+        responseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    totalInputTokens: z.ZodNumber;
+    totalOutputTokens: z.ZodNumber;
+    totalReasoningTokens: z.ZodNumber;
+    toolCallsSummary: z.ZodArray<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
+    userPrompt: z.ZodOptional<z.ZodString>;
+    chatId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    transport: z.ZodOptional<z.ZodString>;
+    phases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        durationMs: z.ZodNumber;
+        position: z.ZodEnum<{
+            pre: "pre";
+            post: "post";
+        }>;
+        startOffsetMs: z.ZodOptional<z.ZodNumber>;
+        endOffsetMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    totalPreStreamingMs: z.ZodOptional<z.ZodNumber>;
+    totalPostStreamingMs: z.ZodOptional<z.ZodNumber>;
+    milestones: z.ZodOptional<z.ZodObject<{
+        turnStarted: z.ZodOptional<z.ZodNumber>;
+        providerInvoked: z.ZodOptional<z.ZodNumber>;
+        providerFirstEvent: z.ZodOptional<z.ZodNumber>;
+        providerFirstTextDelta: z.ZodOptional<z.ZodNumber>;
+        responseFirstTextDelta: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    phaseCoverage: z.ZodOptional<z.ZodNumber>;
+    benchmarkRunId: z.ZodOptional<z.ZodString>;
+    eventLoopLag: z.ZodOptional<z.ZodObject<{
+        meanMs: z.ZodNumber;
+        p50Ms: z.ZodNumber;
+        p95Ms: z.ZodNumber;
+        maxMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TimingToolCallDetail = z.infer<typeof TimingToolCallDetailSchema>;
+export type TimingPhaseRecord = z.infer<typeof TimingPhaseRecordSchema>;
+export type TimingStepRecord = z.infer<typeof TimingStepRecordSchema>;
+export type TimingMilestones = z.infer<typeof TimingMilestonesSchema>;
+export type TimingEventLoopLag = z.infer<typeof TimingEventLoopLagSchema>;
+export type TimingEntry = z.infer<typeof TimingEntrySchema>;

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

@@ -22,7 +22,7 @@ export declare const UserOverviewSchema: z.ZodObject<{
     }, z.core.$strip>;
     files: z.ZodObject<{
         documents: z.ZodNumber;
-        attachments: z.ZodNumber;
+        attachmentsNotInKb: z.ZodNumber;
         bytes: z.ZodNumber;
     }, z.core.$strip>;
     memories: z.ZodObject<{

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

@@ -24,6 +24,7 @@ export * from './Media';
 export * from './Member';
 export * from './MessageFeedback';
 export * from './Notification';
+export * from './OpenAiCompat';
 export * from './Organization';
 export * from './OrganizationExternalAuth';
 export * from './OrganizationIdentityProvider';
@@ -33,6 +34,7 @@ export * from './ReasoningChat';
 export * from './RevisedAnswer';
 export * from './StreamError';
 export * from './SubAgent';
+export * from './TimingLog';
 export * from './DocumentFolder';
 export * from './User';
 export * from './UserOverview';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@8wave/ai-elements",
     "private": false,
-    "version": "0.100.0",
+    "version": "0.101.0-beta.1",
     "type": "module",
     "scripts": {
         "dev": "vite --port 8082 --open --host",