Skill MolyKit

Melhores práticas para construir interfaces de chat com IA usando Makepad com MolyKit - um kit de ferramentas para aplicações de chat com IA multiplataforma.

Código fonte: /Users/zhangalex/Work/Projects/FW/robius/moly/moly-kit

Quando Usar

Use esta skill quando:

• Estiver construindo interfaces de chat com IA com Makepad
• Estiver integrando APIs OpenAI ou outros LLMs
• Estiver implementando async multiplataforma para nativo e WASM
• Estiver criando widgets de chat (mensagens, prompts, avatares)
• Estiver lidando com respostas de streaming SSE
• Palavras-chave: molykit, moly-kit, ai chat, bot client, openai makepad, chat widget, sse streaming

Visão Geral

MolyKit oferece:

• Utilitários async multiplataforma (PlatformSend, spawn(), ThreadToken)
• Widgets de chat prontos para uso (Chat, Messages, PromptInput, Avatar)
• Trait BotClient para integração com provedores de IA
• Cliente compatível com OpenAI com streaming SSE
• Tipos de protocolo para mensagens, bots e chamadas de ferramentas
• Suporte a MCP (Model Context Protocol)

Padrões Async Multiplataforma

PlatformSend - Enviar Apenas em Nativo

/// Implies Send only on native platforms, not on WASM
/// - On native: implemented by types that implement Send
/// - On WASM: implemented by ALL types
pub trait PlatformSend: PlatformSendInner {}

/// Boxed future type for cross-platform use
pub type BoxPlatformSendFuture<'a, T> = Pin<Box<dyn PlatformSendFuture<Output = T> + 'a>>;

/// Boxed stream type for cross-platform use
pub type BoxPlatformSendStream<'a, T> = Pin<Box<dyn PlatformSendStream<Item = T> + 'a>>;

Spawning Agnóstico de Plataforma

/// Runs a future independently
/// - Uses tokio on native (requires Send)
/// - Uses wasm-bindgen-futures on WASM (no Send required)
pub fn spawn(fut: impl PlatformSendFuture<Output = ()> + 'static);

// Usage
spawn(async move {
    let result = fetch_data().await;
    Cx::post_action(DataReady(result));
    SignalToUI::set_ui_signal();
});

Cancelamento de Tarefas com AbortOnDropHandle

/// Handle that aborts its future when dropped
pub struct AbortOnDropHandle(AbortHandle);

// Usage - task cancelled when widget dropped
#[rust]
task_handle: Option<AbortOnDropHandle>,

fn start_task(&mut self) {
    let (future, handle) = abort_on_drop(async move {
        // async work...
    });
    self.task_handle = Some(handle);
    spawn(async move { let _ = future.await; });
}

ThreadToken para Tipos Não-Send em WASM

/// Store non-Send value in thread-local, access via token
pub struct ThreadToken<T: 'static>;

impl<T> ThreadToken<T> {
    pub fn new(value: T) -> Self;
    pub fn peek<R>(&self, f: impl FnOnce(&T) -> R) -> R;
    pub fn peek_mut<R>(&self, f: impl FnOnce(&mut T) -> R) -> R;
}

// Usage - wrap non-Send type for use across Send boundaries
let token = ThreadToken::new(non_send_value);
spawn(async move {
    token.peek(|value| {
        // use value...
    });
});

Trait BotClient

Implementando Integração com Provedores de IA

pub trait BotClient: Send {
    /// Send message with streamed response
    fn send(
        &mut self,
        bot_id: &BotId,
        messages: &[Message],
        tools: &[Tool],
    ) -> BoxPlatformSendStream<'static, ClientResult<MessageContent>>;

    /// Get available bots/models
    fn bots(&self) -> BoxPlatformSendFuture<'static, ClientResult<Vec<Bot>>>;

    /// Clone for passing around
    fn clone_box(&self) -> Box<dyn BotClient>;
}

// Usage
let client = OpenAIClient::new("https://api.openai.com/v1".into());
client.set_key("sk-...")?;
let context = BotContext::from(client);

BotContext - Wrapper Compartilhável

/// Sharable wrapper with loaded bots for sync UI access
pub struct BotContext(Arc<Mutex<InnerBotContext>>);

impl BotContext {
    pub fn load(&mut self) -> BoxPlatformSendFuture<ClientResult<()>>;
    pub fn bots(&self) -> Vec<Bot>;
    pub fn get_bot(&self, id: &BotId) -> Option<Bot>;
    pub fn client(&self) -> Box<dyn BotClient>;
}

// Usage
let mut context = BotContext::from(client);
spawn(async move {
    if let Err(errors) = context.load().await.into_result() {
        // handle errors
    }
    Cx::post_action(BotsLoaded);
});

Tipos de Protocolo

Estrutura da Mensagem

pub struct Message {
    pub from: EntityId,         // User, System, Bot(BotId), App
    pub metadata: MessageMetadata,
    pub content: MessageContent,
}

pub struct MessageContent {
    pub text: String,           // Conteúdo principal (markdown)
    pub reasoning: String,      // Raciocínio/pensamento da IA

…