@copilotkitnext/react 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,363 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { AssistantMessage, Message, UserMessage, ToolCall, ToolMessage } from '@ag-ui/core';
+import { ToolCallStatus, FrontendTool, CopilotKitCore } from '@copilotkitnext/core';
+import { z } from 'zod';
+import { AbstractAgent, Context } from '@ag-ui/client';
+
+declare const CopilotChatDefaultLabels: {
+    chatInputPlaceholder: string;
+    chatInputToolbarStartTranscribeButtonLabel: string;
+    chatInputToolbarCancelTranscribeButtonLabel: string;
+    chatInputToolbarFinishTranscribeButtonLabel: string;
+    chatInputToolbarAddButtonLabel: string;
+    chatInputToolbarToolsButtonLabel: string;
+    assistantMessageToolbarCopyCodeLabel: string;
+    assistantMessageToolbarCopyCodeCopiedLabel: string;
+    assistantMessageToolbarCopyMessageLabel: string;
+    assistantMessageToolbarThumbsUpLabel: string;
+    assistantMessageToolbarThumbsDownLabel: string;
+    assistantMessageToolbarReadAloudLabel: string;
+    assistantMessageToolbarRegenerateLabel: string;
+    userMessageToolbarCopyMessageLabel: string;
+    userMessageToolbarEditMessageLabel: string;
+    chatDisclaimerText: string;
+};
+type CopilotChatLabels = typeof CopilotChatDefaultLabels;
+interface CopilotChatConfigurationValue {
+    labels: CopilotChatLabels;
+    inputValue?: string;
+    onSubmitInput?: (value: string) => void;
+    onChangeInput?: (value: string) => void;
+}
+interface CopilotChatConfigurationProviderProps {
+    children: ReactNode;
+    labels?: Partial<CopilotChatLabels>;
+    inputValue?: string;
+    onSubmitInput?: (value: string) => void;
+    onChangeInput?: (value: string) => void;
+}
+declare const CopilotChatConfigurationProvider: React__default.FC<CopilotChatConfigurationProviderProps>;
+declare const useCopilotChatConfiguration: () => CopilotChatConfigurationValue;
+
+/** Finite-state machine for every recorder implementation */
+type AudioRecorderState = "idle" | "recording" | "processing";
+/** Error subclass so callers can `instanceof`-guard recorder failures */
+declare class AudioRecorderError extends Error {
+    constructor(message: string);
+}
+declare const CopilotChatAudioRecorder: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<any>>;
+
+/** Existing union (unchanged) */
+type SlotValue<C extends React__default.ComponentType<any>> = C | string | Partial<React__default.ComponentProps<C>>;
+/** Utility: concrete React elements for every slot */
+type SlotElements<S> = {
+    [K in keyof S]: React__default.ReactElement;
+};
+type WithSlots<S extends Record<string, React__default.ComponentType<any>>, Rest = {}> = {
+    [K in keyof S]?: SlotValue<S[K]>;
+} & {
+    children?: (props: SlotElements<S> & Rest) => React__default.ReactNode;
+} & Omit<Rest, "children">;
+
+type CopilotChatInputMode = "input" | "transcribe" | "processing";
+type ToolsMenuItem = {
+    label: string;
+} & ({
+    action: () => void;
+    items?: never;
+} | {
+    action?: never;
+    items: (ToolsMenuItem | "-")[];
+});
+type CopilotChatInputProps = WithSlots<{
+    textArea: typeof CopilotChatInput.TextArea;
+    sendButton: typeof CopilotChatInput.SendButton;
+    startTranscribeButton: typeof CopilotChatInput.StartTranscribeButton;
+    cancelTranscribeButton: typeof CopilotChatInput.CancelTranscribeButton;
+    finishTranscribeButton: typeof CopilotChatInput.FinishTranscribeButton;
+    addFileButton: typeof CopilotChatInput.AddFileButton;
+    toolsButton: typeof CopilotChatInput.ToolsButton;
+    toolbar: typeof CopilotChatInput.Toolbar;
+    audioRecorder: typeof CopilotChatAudioRecorder;
+}, {
+    mode?: CopilotChatInputMode;
+    toolsMenu?: (ToolsMenuItem | "-")[];
+    autoFocus?: boolean;
+    additionalToolbarItems?: React__default.ReactNode;
+    onSubmitMessage?: (value: string) => void;
+    onStartTranscribe?: () => void;
+    onCancelTranscribe?: () => void;
+    onFinishTranscribe?: () => void;
+    onAddFile?: () => void;
+    value?: string;
+    onChange?: (value: string) => void;
+} & Omit<React__default.HTMLAttributes<HTMLDivElement>, "onChange">>;
+declare function CopilotChatInput({ mode, onSubmitMessage, onStartTranscribe, onCancelTranscribe, onFinishTranscribe, onAddFile, onChange, value, toolsMenu, autoFocus, additionalToolbarItems, textArea, sendButton, startTranscribeButton, cancelTranscribeButton, finishTranscribeButton, addFileButton, toolsButton, toolbar, audioRecorder, children, className, ...props }: CopilotChatInputProps): react_jsx_runtime.JSX.Element;
+declare namespace CopilotChatInput {
+    const SendButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const ToolbarButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement> & {
+        icon: React__default.ReactNode;
+        labelKey: keyof CopilotChatLabels;
+        defaultClassName?: string;
+    }>;
+    const StartTranscribeButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const CancelTranscribeButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const FinishTranscribeButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const AddFileButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const ToolsButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement> & {
+        toolsMenu?: (ToolsMenuItem | "-")[];
+    }>;
+    const Toolbar: React__default.FC<React__default.HTMLAttributes<HTMLDivElement>>;
+    interface TextAreaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+        maxRows?: number;
+    }
+    const TextArea: React__default.ForwardRefExoticComponent<TextAreaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+    const AudioRecorder: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<any>>;
+}
+
+type CopilotChatToolCallsViewProps = {
+    message: AssistantMessage;
+    messages?: Message[];
+    isLoading?: boolean;
+};
+declare function CopilotChatToolCallsView({ message, messages, isLoading, }: CopilotChatToolCallsViewProps): react_jsx_runtime.JSX.Element | null;
+
+type CopilotChatAssistantMessageProps = WithSlots<{
+    markdownRenderer: typeof CopilotChatAssistantMessage.MarkdownRenderer;
+    toolbar: typeof CopilotChatAssistantMessage.Toolbar;
+    copyButton: typeof CopilotChatAssistantMessage.CopyButton;
+    thumbsUpButton: typeof CopilotChatAssistantMessage.ThumbsUpButton;
+    thumbsDownButton: typeof CopilotChatAssistantMessage.ThumbsDownButton;
+    readAloudButton: typeof CopilotChatAssistantMessage.ReadAloudButton;
+    regenerateButton: typeof CopilotChatAssistantMessage.RegenerateButton;
+    toolCallsView: typeof CopilotChatToolCallsView;
+}, {
+    onThumbsUp?: (message: AssistantMessage) => void;
+    onThumbsDown?: (message: AssistantMessage) => void;
+    onReadAloud?: (message: AssistantMessage) => void;
+    onRegenerate?: (message: AssistantMessage) => void;
+    message: AssistantMessage;
+    messages?: Message[];
+    isLoading?: boolean;
+    additionalToolbarItems?: React.ReactNode;
+    toolbarVisible?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatAssistantMessage({ message, messages, isLoading, onThumbsUp, onThumbsDown, onReadAloud, onRegenerate, additionalToolbarItems, toolbarVisible, markdownRenderer, toolbar, copyButton, thumbsUpButton, thumbsDownButton, readAloudButton, regenerateButton, toolCallsView, children, className, ...props }: CopilotChatAssistantMessageProps): react_jsx_runtime.JSX.Element;
+declare namespace CopilotChatAssistantMessage {
+    const MarkdownRenderer: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+        content: string;
+    }>;
+    const Toolbar: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+    const ToolbarButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+        title: string;
+        children: React.ReactNode;
+    }>;
+    const CopyButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const ThumbsUpButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const ThumbsDownButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const ReadAloudButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const RegenerateButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+}
+
+interface CopilotChatUserMessageOnEditMessageProps {
+    message: UserMessage;
+}
+interface CopilotChatUserMessageOnSwitchToBranchProps {
+    message: UserMessage;
+    branchIndex: number;
+    numberOfBranches: number;
+}
+type CopilotChatUserMessageProps = WithSlots<{
+    messageRenderer: typeof CopilotChatUserMessage.MessageRenderer;
+    toolbar: typeof CopilotChatUserMessage.Toolbar;
+    copyButton: typeof CopilotChatUserMessage.CopyButton;
+    editButton: typeof CopilotChatUserMessage.EditButton;
+    branchNavigation: typeof CopilotChatUserMessage.BranchNavigation;
+}, {
+    onEditMessage?: (props: CopilotChatUserMessageOnEditMessageProps) => void;
+    onSwitchToBranch?: (props: CopilotChatUserMessageOnSwitchToBranchProps) => void;
+    message: UserMessage;
+    branchIndex?: number;
+    numberOfBranches?: number;
+    additionalToolbarItems?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatUserMessage({ message, onEditMessage, branchIndex, numberOfBranches, onSwitchToBranch, additionalToolbarItems, messageRenderer, toolbar, copyButton, editButton, branchNavigation, children, className, ...props }: CopilotChatUserMessageProps): react_jsx_runtime.JSX.Element;
+declare namespace CopilotChatUserMessage {
+    const Container: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLDivElement>>>;
+    const MessageRenderer: React.FC<{
+        content: string;
+        className?: string;
+    }>;
+    const Toolbar: React.FC<React.HTMLAttributes<HTMLDivElement>>;
+    const ToolbarButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+        title: string;
+        children: React.ReactNode;
+    }>;
+    const CopyButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+        copied?: boolean;
+    }>;
+    const EditButton: React.FC<React.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const BranchNavigation: React.FC<React.HTMLAttributes<HTMLDivElement> & {
+        currentBranch?: number;
+        numberOfBranches?: number;
+        onSwitchToBranch?: (props: CopilotChatUserMessageOnSwitchToBranchProps) => void;
+        message: UserMessage;
+    }>;
+}
+
+type CopilotChatMessageViewProps = Omit<WithSlots<{
+    assistantMessage: typeof CopilotChatAssistantMessage;
+    userMessage: typeof CopilotChatUserMessage;
+    cursor: typeof CopilotChatMessageView.Cursor;
+}, {
+    isLoading?: boolean;
+    messages?: Message[];
+} & React.HTMLAttributes<HTMLDivElement>>, "children"> & {
+    children?: (props: {
+        isLoading: boolean;
+        messages: Message[];
+        messageElements: React.ReactElement[];
+    }) => React.ReactElement;
+};
+declare function CopilotChatMessageView({ messages, assistantMessage, userMessage, cursor, isLoading, children, className, ...props }: CopilotChatMessageViewProps): react_jsx_runtime.JSX.Element;
+declare namespace CopilotChatMessageView {
+    var Cursor: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => react_jsx_runtime.JSX.Element;
+}
+
+type CopilotChatViewProps = WithSlots<{
+    messageView: typeof CopilotChatMessageView;
+    scrollView: React__default.FC<React__default.HTMLAttributes<HTMLDivElement>>;
+    scrollToBottomButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    input: typeof CopilotChatInput;
+    inputContainer: React__default.FC<React__default.HTMLAttributes<HTMLDivElement> & {
+        children: React__default.ReactNode;
+    }>;
+    feather: React__default.FC<React__default.HTMLAttributes<HTMLDivElement>>;
+    disclaimer: React__default.FC<React__default.HTMLAttributes<HTMLDivElement>>;
+}, {
+    messages?: Message[];
+    autoScroll?: boolean;
+} & React__default.HTMLAttributes<HTMLDivElement>>;
+declare function CopilotChatView({ messageView, input, scrollView, scrollToBottomButton, feather, inputContainer, disclaimer, messages, autoScroll, children, className, ...props }: CopilotChatViewProps): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+declare namespace CopilotChatView {
+    const ScrollView: React__default.FC<React__default.HTMLAttributes<HTMLDivElement> & {
+        autoScroll?: boolean;
+        scrollToBottomButton?: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+        inputContainerHeight?: number;
+        isResizing?: boolean;
+    }>;
+    const ScrollToBottomButton: React__default.FC<React__default.ButtonHTMLAttributes<HTMLButtonElement>>;
+    const Feather: React__default.FC<React__default.HTMLAttributes<HTMLDivElement>>;
+    const InputContainer: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & {
+        children: React__default.ReactNode;
+    } & React__default.RefAttributes<HTMLDivElement>>;
+    const Disclaimer: React__default.FC<React__default.HTMLAttributes<HTMLDivElement>>;
+}
+
+type CopilotChatProps = Omit<CopilotChatViewProps, "messages"> & {
+    agentId?: string;
+    threadId?: string;
+};
+declare function CopilotChat({ agentId, threadId, ...props }: CopilotChatProps): react_jsx_runtime.JSX.Element;
+
+interface UseRenderToolCallProps {
+    toolCall: ToolCall;
+    toolMessage?: ToolMessage;
+    isLoading: boolean;
+}
+/**
+ * Hook that returns a function to render tool calls based on the render functions
+ * defined in CopilotKitProvider.
+ *
+ * @returns A function that takes a tool call and optional tool message and returns the rendered component
+ */
+declare function useRenderToolCall(): ({ toolCall, toolMessage, isLoading, }: UseRenderToolCallProps) => React__default.ReactElement | null;
+
+interface ReactToolCallRender<T> {
+    name: string;
+    args: z.ZodSchema<T>;
+    /**
+     * Optional agent ID to constrain this tool render to a specific agent.
+     * If specified, this render will only be used for the specified agent.
+     */
+    agentId?: string;
+    render: React.ComponentType<{
+        args: Partial<T>;
+        status: ToolCallStatus.InProgress;
+        result: undefined;
+    } | {
+        args: T;
+        status: ToolCallStatus.Executing;
+        result: undefined;
+    } | {
+        args: T;
+        status: ToolCallStatus.Complete;
+        result: string;
+    }>;
+}
+
+type ReactFrontendTool<T extends Record<string, unknown> = Record<string, unknown>> = FrontendTool<T> & {
+    render?: ReactToolCallRender<T>["render"];
+};
+
+declare function useFrontendTool<T extends Record<string, unknown> = Record<string, unknown>>(tool: ReactFrontendTool<T>): void;
+
+type ReactHumanInTheLoop<T extends Record<string, unknown> = Record<string, unknown>> = Omit<FrontendTool<T>, "handler"> & {
+    render: React__default.ComponentType<{
+        name: string;
+        description: string;
+        args: Partial<T>;
+        status: ToolCallStatus.InProgress;
+        result: undefined;
+        respond: undefined;
+    } | {
+        name: string;
+        description: string;
+        args: T;
+        status: ToolCallStatus.Executing;
+        result: undefined;
+        respond: (result: unknown) => Promise<void>;
+    } | {
+        name: string;
+        description: string;
+        args: T;
+        status: ToolCallStatus.Complete;
+        result: string;
+        respond: undefined;
+    }>;
+};
+
+declare function useHumanInTheLoop<T extends Record<string, unknown> = Record<string, unknown>>(tool: ReactHumanInTheLoop<T>): void;
+
+interface UseAgentProps {
+    agentId?: string;
+}
+declare function useAgent({ agentId }?: UseAgentProps): {
+    agent: AbstractAgent | undefined;
+    isRunning: boolean;
+};
+
+declare function useAgentContext(context: Context): void;
+
+interface CopilotKitContextValue {
+    copilotkit: CopilotKitCore;
+    renderToolCalls: ReactToolCallRender<unknown>[];
+    currentRenderToolCalls: ReactToolCallRender<unknown>[];
+    setCurrentRenderToolCalls: React__default.Dispatch<React__default.SetStateAction<ReactToolCallRender<unknown>[]>>;
+}
+interface CopilotKitProviderProps {
+    children: ReactNode;
+    runtimeUrl?: string;
+    headers?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    agents?: Record<string, AbstractAgent>;
+    renderToolCalls?: ReactToolCallRender<unknown>[];
+    frontendTools?: ReactFrontendTool[];
+    humanInTheLoop?: ReactHumanInTheLoop[];
+}
+declare const CopilotKitProvider: React__default.FC<CopilotKitProviderProps>;
+declare const useCopilotKit: () => CopilotKitContextValue;
+
+export { AudioRecorderError, type AudioRecorderState, CopilotChat, CopilotChatAssistantMessage, type CopilotChatAssistantMessageProps, CopilotChatAudioRecorder, CopilotChatConfigurationProvider, type CopilotChatConfigurationProviderProps, type CopilotChatConfigurationValue, CopilotChatInput, type CopilotChatInputProps, type CopilotChatLabels, CopilotChatMessageView, type CopilotChatMessageViewProps, type CopilotChatProps, CopilotChatToolCallsView, type CopilotChatToolCallsViewProps, CopilotChatUserMessage, type CopilotChatUserMessageProps, CopilotChatView, type CopilotChatViewProps, type CopilotKitContextValue, CopilotKitProvider, type CopilotKitProviderProps, type ToolsMenuItem, useAgent, useAgentContext, useCopilotChatConfiguration, useCopilotKit, useFrontendTool, useHumanInTheLoop, useRenderToolCall };