@plitzi/plitzi-builder 0.30.19 → 0.31.1

package/dist/modules/AI/components/ChatMessage/helpers/getStyleGuideResult.d.ts

@@ -0,0 +1,45 @@
+import { AiMessage } from '../../../types';
+export type NamedToken = {
+    name: string;
+    value: string;
+};
+export type ColorScale = Record<string, string>;
+export type StyleGuideData = {
+    name: string;
+    description?: string;
+    colors: {
+        primary: ColorScale;
+        secondary?: ColorScale;
+        accent?: ColorScale;
+        neutral?: ColorScale;
+        semantic?: {
+            success?: string;
+            warning?: string;
+            error?: string;
+            info?: string;
+        };
+    };
+    colorsDark?: {
+        primary?: ColorScale;
+        secondary?: ColorScale;
+        accent?: ColorScale;
+        neutral?: ColorScale;
+    };
+    typography?: {
+        fontFamily: {
+            heading: string;
+            body: string;
+        };
+        scale?: Array<{
+            name: string;
+            size: string;
+            lineHeight: string;
+            weight?: string;
+        }>;
+    };
+    spacing?: NamedToken[];
+    borderRadius?: NamedToken[];
+    shadows?: NamedToken[];
+};
+declare const getStyleGuideResult: (tools?: AiMessage["tools"]) => StyleGuideData | undefined;
+export default getStyleGuideResult;

package/dist/modules/AI/components/ChatMessage/helpers/getWireframeResult.d.ts

@@ -0,0 +1,12 @@
+import { Schema, Style } from '@plitzi/sdk-shared';
+import { AiMessage } from '../../../types';
+export type WireframeData = {
+    baseElementId: string;
+    name: string;
+    description?: string;
+    schema?: Pick<Schema, 'flat'>;
+    style?: Pick<Style, 'platform' | 'cache'>;
+    html?: string;
+};
+declare const getWireframeResult: (tools?: AiMessage["tools"]) => WireframeData | undefined;
+export default getWireframeResult;

package/dist/modules/AI/components/ChatMessage/helpers/utils.d.ts

@@ -0,0 +1 @@
+export declare const formatTime: (ts?: number) => string;

package/dist/modules/AI/components/ChatMessage/index.d.ts

@@ -1 +1,3 @@
-export { default } from './ChatMessage';
+import { default as ChatMessage } from './ChatMessage';
+export * from './ChatMessage';
+export default ChatMessage;

package/dist/modules/AI/components/CopyButton/CopyButton.d.ts

@@ -0,0 +1,7 @@
+export type CopyButtonProps = {
+    text: string;
+    title?: string;
+    className?: string;
+};
+declare const CopyButton: ({ text, title, className }: CopyButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default CopyButton;

package/dist/modules/AI/components/CopyButton/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './CopyButton';
+export type { CopyButtonProps } from './CopyButton';

package/dist/modules/AI/components/HistoryPanel/HistoryPanel.d.ts

@@ -0,0 +1,10 @@
+import { ConversationSummary } from '../../types';
+export type HistoryPanelProps = {
+    conversations: ConversationSummary[];
+    currentConversationId?: string;
+    onClose: () => void;
+    onSelect: (id: string) => void;
+    onNew: () => void;
+};
+declare const HistoryPanel: ({ conversations, currentConversationId, onClose, onSelect, onNew }: HistoryPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default HistoryPanel;

package/dist/modules/AI/components/HistoryPanel/components/ConversationList/ConversationList.d.ts

@@ -0,0 +1,9 @@
+import { ConversationGroup } from '../../types';
+export type ConversationListProps = {
+    groups: ConversationGroup[];
+    highlighted: number;
+    onHighlight: (index: number) => void;
+    onSelect: (id: string) => void;
+};
+declare const ConversationList: ({ groups, highlighted, onHighlight, onSelect }: ConversationListProps) => import("react/jsx-runtime").JSX.Element;
+export default ConversationList;

package/dist/modules/AI/components/HistoryPanel/components/ConversationList/components/ConversationItem/ConversationItem.d.ts

@@ -0,0 +1,11 @@
+import { EnrichedConversation } from '../../../../types';
+export type ConversationItemProps = {
+    conversation: EnrichedConversation;
+    rowNum: number;
+    isHighlighted: boolean;
+    isCurrent: boolean;
+    onSelect: (id: string) => void;
+    onHighlight: (index: number) => void;
+};
+declare const ConversationItem: ({ conversation, rowNum, isHighlighted, isCurrent, onSelect, onHighlight }: ConversationItemProps) => import("react/jsx-runtime").JSX.Element;
+export default ConversationItem;

package/dist/modules/AI/components/HistoryPanel/components/ConversationList/components/ConversationItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ConversationItem } from './ConversationItem';
+export * from './ConversationItem';
+export default ConversationItem;

package/dist/modules/AI/components/HistoryPanel/components/ConversationList/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ConversationList } from './ConversationList';
+export * from './ConversationList';
+export default ConversationList;

package/dist/modules/AI/components/HistoryPanel/components/HistoryFooter/HistoryFooter.d.ts

@@ -0,0 +1,5 @@
+export type HistoryFooterProps = {
+    onNew: () => void;
+};
+declare const HistoryFooter: ({ onNew }: HistoryFooterProps) => import("react/jsx-runtime").JSX.Element;
+export default HistoryFooter;

package/dist/modules/AI/components/HistoryPanel/components/HistoryFooter/index.d.ts

@@ -0,0 +1,3 @@
+import { default as HistoryFooter } from './HistoryFooter';
+export * from './HistoryFooter';
+export default HistoryFooter;

package/dist/modules/AI/components/HistoryPanel/components/HistorySearch/HistorySearch.d.ts

@@ -0,0 +1,6 @@
+export type HistorySearchProps = {
+    value: string;
+    onChange: (value: string) => void;
+};
+declare const HistorySearch: ({ value, onChange }: HistorySearchProps) => import("react/jsx-runtime").JSX.Element;
+export default HistorySearch;

package/dist/modules/AI/components/HistoryPanel/components/HistorySearch/index.d.ts

@@ -0,0 +1,3 @@
+import { default as HistorySearch } from './HistorySearch';
+export * from './HistorySearch';
+export default HistorySearch;

package/dist/modules/AI/components/HistoryPanel/helpers.d.ts

@@ -0,0 +1 @@
+export declare const GROUP_LABELS: Record<string, string>;

package/dist/modules/AI/components/HistoryPanel/index.d.ts

@@ -0,0 +1,3 @@
+import { default as HistoryPanel } from './HistoryPanel';
+export * from './HistoryPanel';
+export default HistoryPanel;

package/dist/modules/AI/components/HistoryPanel/types.d.ts

@@ -0,0 +1,10 @@
+import { ConversationSummary } from '../../types';
+export type EnrichedConversation = ConversationSummary & {
+    rowIndex: number;
+    isCurrent: boolean;
+};
+export type ConversationGroup = {
+    key: string;
+    label: string;
+    items: EnrichedConversation[];
+};

package/dist/modules/AI/components/KeyboardKey/KeyboardKey.d.ts

@@ -0,0 +1,7 @@
+export type KeyboardKeyProps = {
+    className?: string;
+    commandChar?: boolean;
+    char: string;
+};
+declare const KeyboardKey: ({ className, commandChar, char }: KeyboardKeyProps) => import("react/jsx-runtime").JSX.Element;
+export default KeyboardKey;

package/dist/modules/AI/components/KeyboardKey/index.d.ts

@@ -0,0 +1,3 @@
+import { default as KeyboardKey } from './KeyboardKey';
+export * from './KeyboardKey';
+export default KeyboardKey;

package/dist/modules/AI/components/MessageTools/MessageTools.d.ts

@@ -0,0 +1,7 @@
+import { AiToolCall } from '../../types';
+export type MessageToolsProps = {
+    tools: AiToolCall[];
+    defaultOpen?: boolean;
+};
+declare const MessageTools: ({ tools, defaultOpen }: MessageToolsProps) => import("react/jsx-runtime").JSX.Element;
+export default MessageTools;

package/dist/modules/AI/components/MessageTools/components/MessageTool/MessageTool.d.ts

@@ -0,0 +1,4 @@
+import { AiToolCall } from '../../../../types';
+export type MessageToolProps = AiToolCall;
+declare const MessageTool: ({ name, args, status, result, error }: MessageToolProps) => import("react/jsx-runtime").JSX.Element;
+export default MessageTool;

package/dist/modules/AI/components/MessageTools/components/MessageTool/humanizeToolName.d.ts

@@ -0,0 +1 @@
+export declare const humanizeToolName: (name: string) => string;

package/dist/modules/AI/components/MessageTools/components/MessageTool/index.d.ts

@@ -0,0 +1,3 @@
+import { default as MessageTool } from './MessageTool';
+export * from './MessageTool';
+export default MessageTool;

package/dist/modules/AI/components/MessageTools/index.d.ts

@@ -0,0 +1,3 @@
+import { default as MessageTools } from './MessageTools';
+export * from './MessageTools';
+export default MessageTools;

package/dist/modules/AI/components/ModeLabel/ModeLabel.d.ts

@@ -0,0 +1,6 @@
+import { AiMode } from '../../types';
+export type ModeLabelProps = {
+    mode?: AiMode;
+};
+declare const ModeLabel: ({ mode }: ModeLabelProps) => import("react/jsx-runtime").JSX.Element;
+export default ModeLabel;

package/dist/modules/AI/components/ModeLabel/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ModeLabel } from './ModeLabel';
+export * from './ModeLabel';
+export default ModeLabel;

package/dist/modules/AI/components/QuotaCountdown/QuotaCountdown.d.ts

@@ -0,0 +1,5 @@
+export type QuotaCountdownProps = {
+    retryAfter: number;
+};
+declare const QuotaCountdown: ({ retryAfter }: QuotaCountdownProps) => import("react/jsx-runtime").JSX.Element;
+export default QuotaCountdown;

package/dist/modules/AI/components/QuotaCountdown/helpers/formatRetryDelay.d.ts

@@ -0,0 +1,2 @@
+declare const formatRetryDelay: (ts: number) => string;
+export default formatRetryDelay;

package/dist/modules/AI/components/QuotaCountdown/index.d.ts

@@ -0,0 +1,3 @@
+import { default as QuotaCountdown } from './QuotaCountdown';
+export * from './QuotaCountdown';
+export default QuotaCountdown;

package/dist/modules/AI/components/ToggleMode/ToggleMode.d.ts

@@ -0,0 +1,8 @@
+import { AiMode } from '../../types';
+export type ToggleModeProps = {
+    mode: AiMode;
+    disabled?: boolean;
+    onModeChange?: (mode: AiMode) => void;
+};
+declare const ToggleMode: ({ mode, disabled, onModeChange }: ToggleModeProps) => import("react/jsx-runtime").JSX.Element;
+export default ToggleMode;

package/dist/modules/AI/components/ToggleMode/components/ToggleItem/ToggleItem.d.ts

@@ -0,0 +1,10 @@
+import { AiMode } from '../../../../types';
+export type ToggleItemProps = {
+    mode: AiMode;
+    active?: boolean;
+    disabled?: boolean;
+    title?: string;
+    onClick?: (mode: AiMode) => void;
+};
+declare const ToggleItem: ({ mode, active, disabled, title, onClick }: ToggleItemProps) => import("react/jsx-runtime").JSX.Element;
+export default ToggleItem;

package/dist/modules/AI/components/ToggleMode/components/ToggleItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ToggleItem } from './ToggleItem';
+export * from './ToggleItem';
+export default ToggleItem;

package/dist/modules/AI/components/ToggleMode/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ToggleMode } from './ToggleMode';
+export * from './ToggleMode';
+export default ToggleMode;

package/dist/modules/AI/components/ToolVisualRenderer/ToolVisualRenderer.d.ts

@@ -0,0 +1,10 @@
+import { ToolVisual } from '../ChatMessage/helpers/extractToolVisual';
+import { AiMode } from '../../types';
+export type ToolVisualRendererProps = {
+    visual: ToolVisual;
+    mode?: AiMode;
+    stagePreviewVersion?: number;
+    wireframeVersion?: number;
+};
+declare const ToolVisualRenderer: ({ visual, mode, stagePreviewVersion, wireframeVersion }: ToolVisualRendererProps) => import("react/jsx-runtime").JSX.Element;
+export default ToolVisualRenderer;

package/dist/modules/AI/components/ToolVisualRenderer/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ToolVisualRenderer';
+export type { ToolVisualRendererProps } from './ToolVisualRenderer';

package/dist/modules/AI/contexts/AiChatContext.d.ts

@@ -0,0 +1,37 @@
+import { AiQuestion } from '../components/ChatInput/components/QuestionInput';
+import { AiAttachment, AiLiveStep, AiMessage, AiMode, AiUsage, ConversationSummary } from '../types';
+import { AiEffort } from '@plitzi/sdk-shared';
+export type AiChatContextValue = {
+    messages: AiMessage[];
+    streamingText: string;
+    liveSteps: AiLiveStep[];
+    isStreaming: boolean;
+    isBusy: boolean;
+    usage: AiUsage | undefined;
+    error: string | undefined;
+    quotaError: string | undefined;
+    quotaRetryAfter: number | undefined;
+    conversationId: string;
+    conversations: ConversationSummary[];
+    pendingQuestion: AiQuestion[] | null;
+    mode: AiMode;
+    currentMode: AiMode;
+    conversationTitle: string | undefined;
+    elementSelected: string | undefined;
+    onSend: (message: string, attachments: AiAttachment[], effort: AiEffort) => void;
+    onSendMessage: (message: string) => void;
+    setMode: (mode: AiMode) => void;
+    stopGeneration: () => void;
+    clearError: () => void;
+    clearQuotaError: () => void;
+    clearConversation: () => void;
+    loadConversations: () => Promise<void>;
+    loadConversation: (id: string) => Promise<void>;
+    forkFromMessage: (messageId: string, content: string) => Promise<void>;
+    newChatFromMessage: (content: string) => void;
+    prefillInput: (text: string) => void;
+    compact: () => Promise<void>;
+};
+declare const AiChatContext: import('react').Context<AiChatContextValue>;
+export declare const useAiChatContext: () => AiChatContextValue;
+export default AiChatContext;

package/dist/modules/AI/contexts/AiChatProvider.d.ts

@@ -0,0 +1,9 @@
+import { AiProviderSettings } from '../types';
+import { ReactNode } from 'react';
+export type AiChatProviderProps = {
+    children: ReactNode;
+    providerSettings?: AiProviderSettings;
+    prefillInput?: (text: string) => void;
+};
+declare const AiChatProvider: ({ children, providerSettings, prefillInput }: AiChatProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default AiChatProvider;

package/dist/modules/AI/helpers/computeUsageFromMessages.d.ts

@@ -0,0 +1,3 @@
+import { AiMessage, AiUsage } from '../types';
+declare const computeUsageFromMessages: (msgs: AiMessage[]) => AiUsage | undefined;
+export default computeUsageFromMessages;

package/dist/modules/AI/helpers/formatDuration.d.ts

@@ -0,0 +1,2 @@
+declare const formatDuration: (ms: number) => string;
+export default formatDuration;

package/dist/modules/AI/helpers/getDateGroup.d.ts

@@ -0,0 +1,2 @@
+declare const getDateGroup: (dateStr: string) => "today" | "yesterday" | "week" | "older";
+export default getDateGroup;

package/dist/modules/AI/helpers/parseAiStream.d.ts

@@ -0,0 +1,2 @@
+import { AiStreamEvent } from '../types';
+export declare function parseAiStream(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<AiStreamEvent>;

package/dist/modules/AI/helpers/relativeTime.d.ts

@@ -0,0 +1,2 @@
+declare const relativeTime: (dateStr: string) => string;
+export default relativeTime;

package/dist/modules/AI/hooks/useAiChat.d.ts

@@ -1,15 +1,36 @@
-import { AiFrontendToolRunner } from '../tools';
-import { AiAttachment, AiContext, AiMessage, AiProviderSettings, AiToolCall, AiUsage } from '../types';
-declare const useAiChat: (runClientTool?: AiFrontendToolRunner, providerSettings?: AiProviderSettings) => {
+import { AiAttachment, AiContext, AiMessage, AiProviderSettings, ConversationSummary } from '../types';
+import { AiEffort, AiMode } from '@plitzi/sdk-shared';
+type QueueEntry = {
+    localId: string;
+    message: string;
+    context: AiContext;
+    attachments: AiAttachment[];
+    effort: AiEffort;
+};
+declare const useAiChat: (providerSettings?: AiProviderSettings) => {
     messages: AiMessage[];
     streamingText: string;
-    liveThinking: string;
-    liveTools: AiToolCall[];
+    liveSteps: import('../types').AiLiveStep[];
     isStreaming: boolean;
-    usage: AiUsage | undefined;
+    isBusy: boolean;
+    usage: import('@plitzi/sdk-shared').AiUsage | undefined;
+    error: string | undefined;
+    clearError: () => void;
+    quotaError: string | undefined;
+    clearQuotaError: () => void;
+    quotaRetryAfter: number | undefined;
+    conversationId: string;
+    conversations: ConversationSummary[];
+    pendingQueue: QueueEntry[];
+    mode: AiMode;
+    setMode: import('react').Dispatch<import('react').SetStateAction<AiMode>>;
     initConversation: () => Promise<void>;
-    sendMessage: (message: string, context: AiContext, attachments?: AiAttachment[]) => Promise<void>;
+    sendMessage: (message: string, context: AiContext, attachments?: AiAttachment[], effort?: AiEffort) => Promise<void>;
+    stopGeneration: () => void;
     clearConversation: () => void;
+    loadConversations: () => Promise<void>;
+    loadConversation: (id: string) => Promise<void>;
+    forkConversation: (messageId: string) => Promise<string | null>;
     compact: () => Promise<void>;
 };
 export default useAiChat;

package/dist/modules/AI/hooks/useAiErrors.d.ts

@@ -0,0 +1,11 @@
+declare const useAiErrors: () => {
+    error: string | undefined;
+    setError: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
+    quotaError: string | undefined;
+    quotaRetryAfter: number | undefined;
+    clearError: () => void;
+    clearQuotaError: () => void;
+    clearAll: () => void;
+    setQuotaLimitError: (message: string, retryAfter: number) => void;
+};
+export default useAiErrors;

package/dist/modules/AI/hooks/useAiUsage.d.ts

@@ -0,0 +1,8 @@
+import { AiMessage, AiUsage } from '../types';
+declare const useAiUsage: () => {
+    usage: AiUsage | undefined;
+    accumulate: (newRaw: AiUsage) => void;
+    reset: () => void;
+    loadFromMessages: (msgs: AiMessage[]) => void;
+};
+export default useAiUsage;

package/dist/modules/AI/hooks/useLiveSteps.d.ts

@@ -0,0 +1,23 @@
+import { AiLiveStep, AiStreamEvent } from '../types';
+type ThinkingEvent = Extract<AiStreamEvent, {
+    type: 'thinking';
+}>;
+type ToolStartEvent = Extract<AiStreamEvent, {
+    type: 'tool_start';
+}>;
+type ToolEvent = Extract<AiStreamEvent, {
+    type: 'tool';
+}>;
+type ResourceReadEvent = Extract<AiStreamEvent, {
+    type: 'resource_read';
+}>;
+declare const useLiveSteps: (capture: () => string) => {
+    liveSteps: AiLiveStep[];
+    clear: () => void;
+    onThinking: (event: ThinkingEvent) => void;
+    onChunk: () => void;
+    onToolStart: (event: ToolStartEvent) => void;
+    onTool: (event: ToolEvent) => void;
+    onResourceRead: (event: ResourceReadEvent) => void;
+};
+export default useLiveSteps;

package/dist/modules/AI/hooks/useStreamingText.d.ts

@@ -0,0 +1,7 @@
+declare const useStreamingText: () => {
+    streamingText: string;
+    appendChunk: (text: string) => void;
+    flush: () => void;
+    capture: () => string;
+};
+export default useStreamingText;

package/dist/modules/AI/index.d.ts

@@ -1,2 +1 @@
 export { default } from './AiChat';
-export { default as AiChatPreview } from './AiChatPreview';

package/dist/modules/AI/types.d.ts

@@ -1,18 +1,30 @@
-import { Schema, Style } from '@plitzi/sdk-shared';
-export type AiRole = 'user' | 'assistant';
-export type AiAttachment = {
+import { AiMessageAttachment, AiMessageStep, AiMode, AiProviderType, AiRole, AiToolCall, AIToolStatus, AiUsage, Theme } from '@plitzi/sdk-shared';
+export type { AiEffort, AiMode, AiMessageStep, AiProviderType, AiToolCall, AiUsage, ConversationSummary } from '@plitzi/sdk-shared';
+export type AiAttachment = AiMessageAttachment & {
     id: string;
-    type: 'image';
-    mimeType: string;
-    data: string;
     name: string;
 };
-export type AiToolCall = {
+export type AiLiveStep = {
+    type: 'thinking';
+    text: string;
+    done: boolean;
+    durationMs?: number;
+    startMs: number;
+} | {
+    type: 'tool';
     id: string;
     name: string;
     args?: Record<string, unknown>;
     result?: unknown;
-    status: 'running' | 'done';
+    error?: string;
+    status: AIToolStatus;
+} | {
+    type: 'resource';
+    name: string;
+    uri: string;
+} | {
+    type: 'text';
+    text: string;
 };
 export type AiMessagePreview = {
     elementId: string;
@@ -20,14 +32,34 @@ export type AiMessagePreview = {
 } | {
     baseElementId: string;
     elementId?: never;
-    schema: Pick<Schema, 'flat'>;
-    style: Pick<Style, 'platform' | 'cache'>;
-};
+    schema?: {
+        flat: Record<string, unknown>;
+    };
+    style?: {
+        platform?: unknown;
+        cache?: string;
+    };
+    elements?: Array<Record<string, unknown>>;
+    success?: boolean;
+    validationErrors?: Array<{
+        code: string;
+        message: string;
+        elementId?: string;
+        details?: unknown;
+    }>;
+    validationWarnings?: Array<string>;
+    message?: string;
+} | Record<string, unknown>;
 export type AiMessageAction = {
     id: string;
     label: string;
     variant?: 'primary' | 'danger' | 'default';
 };
+export type AiMessageClientTool = {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+};
 export type AiMessage = {
     id: string;
     role: AiRole;
@@ -35,19 +67,18 @@ export type AiMessage = {
     thinking?: string;
     thinkingDurationMs?: number;
     irrelevant?: boolean;
+    queued?: boolean;
+    compactionSummary?: boolean;
+    mode?: AiMode;
+    usage?: AiUsage;
     preview?: AiMessagePreview;
     actions?: AiMessageAction[];
     attachments?: AiAttachment[];
     tools?: AiToolCall[];
+    steps?: AiMessageStep[];
+    clientTools?: AiMessageClientTool[];
     createdAt: number;
 };
-export type AiUsage = {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    contextLimit: number;
-    usedPercent: number;
-};
 export type AiStreamEvent = {
     type: 'chunk';
     text: string;
@@ -63,11 +94,14 @@ export type AiStreamEvent = {
     name: string;
     args: Record<string, unknown>;
     result: unknown;
+    error?: string;
+    status: 'done' | 'failed';
 } | {
-    type: 'client_tool';
-    id: string;
+    type: 'resource_read';
     name: string;
-    args: Record<string, unknown>;
+    uri: string;
+} | {
+    type: 'busy';
 } | {
     type: 'done';
     message: AiMessage;
@@ -75,14 +109,15 @@ export type AiStreamEvent = {
 } | {
     type: 'error';
     message: string;
+    retryAfter?: number;
 };
 export type AiContext = {
     spaceId?: number;
     environment?: string;
     currentPageId?: string;
     elementSelected?: string;
+    theme?: Theme;
 };
-export type AiProviderType = 'openai' | 'anthropic' | 'ollama' | 'openrouter' | 'opencode';
 export type AiProviderSettings = {
     provider?: AiProviderType;
     apiKey?: string;
@@ -95,4 +130,21 @@ export type AiModelInfo = {
     providerID?: string;
     providerName?: string;
     free?: boolean;
+    contextLimit?: number;
+    supportsThinking?: boolean;
+};
+export type AiSkillSource = 'builtin' | 'team' | 'mine';
+export type AiSkillCategory = 'design' | 'content' | 'data' | 'performance' | 'integrations' | 'enterprise';
+export type AiSkill = {
+    id: string;
+    name: string;
+    slash: string;
+    source: AiSkillSource;
+    cat: AiSkillCategory;
+    desc: string;
+    enabled: boolean;
+    enterprise?: boolean;
+    runs?: number;
+    avg?: string;
+    lastUsed?: string;
 };

package/dist/modules/Interactions/components/Workflow/Workflow.d.ts

@@ -1,11 +1,12 @@
-import { ElementInteraction, InteractionCallback } from '@plitzi/sdk-shared';
+import { ElementInteraction, InteractionCallback, Source } from '@plitzi/sdk-shared';
 export type WorkflowProps = {
     nodes?: Record<string, ElementInteraction>;
     triggerTitle?: string;
     callbackTitle?: string;
     nodeDefinitions?: InteractionCallback[];
     direction?: 'horizontal' | 'vertical';
+    dataSource?: Record<string, Source['meta']>;
     onChange?: (nodes: Record<string, ElementInteraction>) => void;
 };
-declare const Workflow: ({ nodes: nodesProp, triggerTitle, callbackTitle, nodeDefinitions, direction, onChange }: WorkflowProps) => import("react/jsx-runtime").JSX.Element;
+declare const Workflow: ({ nodes: nodesProp, triggerTitle, callbackTitle, nodeDefinitions, direction, dataSource, onChange }: WorkflowProps) => import("react/jsx-runtime").JSX.Element;
 export default Workflow;