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

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

@@ -20,8 +20,8 @@ type __VLS_Props = {
     fallbackModels?: string[];
     gatewayOptions?: Partial<AgentGatewayOptions>;
     externalContext?: Record<string, unknown>;
-    /** Layout modifier: `widget` (default) keeps the contained layout with header, `fullscreen` removes header/background for full-page usage (the page provides the chrome) */
-    modifier?: 'widget' | 'fullscreen';
+    /** Layout modifier: `widget` (default) keeps the contained layout with header, `fullscreen` removes header/background for full-page usage (the page provides the chrome), `panel` keeps the header but slims it down for a docked side panel (the host provides background and border) */
+    modifier?: 'widget' | 'fullscreen' | 'panel';
     /** Display name of the current user, used for the `{name}` placeholder in the fullscreen greeting */
     userName?: string;
     /** Show the "Files in this chat" menu for hosts that don't provide the
@@ -39,25 +39,25 @@ declare var __VLS_24: {
     contrastColor: "white" | "black";
     startNewChat: () => Promise<string>;
     stopGeneration: () => Promise<void>;
-}, __VLS_103: {
+}, __VLS_117: {
     mainColor: string | undefined;
     useColorsForAgentHeader: boolean | undefined;
     contrastColor: "white" | "black";
     startNewChat: () => Promise<string>;
     stopGeneration: () => Promise<void>;
-}, __VLS_127: string, __VLS_128: any, __VLS_138: string, __VLS_139: any, __VLS_146: {}, __VLS_156: string, __VLS_157: any;
+}, __VLS_141: string, __VLS_142: any, __VLS_152: string, __VLS_153: any, __VLS_160: {}, __VLS_170: string, __VLS_171: any;
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_127>]?: (props: typeof __VLS_128) => any;
+    [K in NonNullable<typeof __VLS_141>]?: (props: typeof __VLS_142) => any;
 } & {
-    [K in NonNullable<typeof __VLS_138>]?: (props: typeof __VLS_139) => any;
+    [K in NonNullable<typeof __VLS_152>]?: (props: typeof __VLS_153) => any;
 } & {
-    [K in NonNullable<typeof __VLS_156>]?: (props: typeof __VLS_157) => any;
+    [K in NonNullable<typeof __VLS_170>]?: (props: typeof __VLS_171) => any;
 } & {
     'header-actions'?: (props: typeof __VLS_24) => any;
 } & {
-    actions?: (props: typeof __VLS_103) => any;
+    actions?: (props: typeof __VLS_117) => any;
 } & {
-    'view-auth'?: (props: typeof __VLS_146) => any;
+    'view-auth'?: (props: typeof __VLS_160) => any;
 };
 declare const __VLS_base: DefineComponent<__VLS_PublicProps, {
     startNewChat: () => Promise<string>;

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

@@ -2,8 +2,8 @@ import { UIChatMessage } from '../../../models/src';
 import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 type __VLS_Props = {
     agentId: string;
-    /** Mirrors the PkChatbot `modifier` prop: `fullscreen` shows a centered empty state (greeting) instead of the welcome message */
-    modifier?: 'widget' | 'fullscreen';
+    /** Mirrors the PkChatbot `modifier` prop: `fullscreen` shows a centered empty state (greeting) instead of the welcome message, `panel` behaves like `widget` */
+    modifier?: 'widget' | 'fullscreen' | 'panel';
     /** Display name of the current user, used for the `{name}` greeting placeholder */
     userName?: string;
 };

package/dist-vue/packages/composable/src/useDialog.d.ts

@@ -2,6 +2,8 @@ import { VNode, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentPr
 type DialogProps = {
     title?: string;
     transition?: string;
+    modifiers?: string | string[];
+    /** @deprecated use modifiers instead */
     size?: 'small' | 'standard' | 'fullscreen';
     role?: 'alert' | 'alertdialog';
     keepOpen?: boolean;

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/OrganizationExternalAuth.d.ts

@@ -1,4 +1,11 @@
 import * as z from 'zod';
+/**
+ * Display name stored when an external token carries no usable name claim and
+ * none can be derived from the other claims. It means "unknown", not "this is
+ * the user's name": consumers must never surface it (greeting someone with
+ * "Hi External User" is a visible defect).
+ */
+export declare const EXTERNAL_USER_PLACEHOLDER_NAME = "External User";
 export declare const OrganizationExternalAuthSchema: z.ZodObject<{
     id: z.ZodString;
     organizationId: z.ZodString;

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<{