Communitygithub.com

majiayu000/claude-skill-registry

CRÍTICO: Use para o kit de chat AI MolyKit. Aciona em: BotClient, OpenAI, streaming SSE, chat AI, molykit, PlatformSend, spawn(), ThreadToken, assíncrono multiplataforma, Widget de chat, Mensagens, PromptInput, Avatar, LLM.

O que é claude-skill-registry?

Esta skill fornece as melhores práticas e padrões para construir interfaces de chat AI com Makepad usando o MolyKit, um kit de ferramentas para aplicações de chat AI multiplataforma. Ela é projetada para desenvolvedores que trabalham com Makepad, OpenAI ou outras APIs LLM, e que precisam implementar funcionalidades assíncronas multiplataforma para ambientes nativos e WASM. A skill cobre tópicos essenciais como o trait BotClient para integração com provedores de IA, padrões de assincronicidade multiplataforma com PlatformSend e spawn(), manipulação de streaming SSE, e widgets de chat prontos como Chat, Messages, PromptInput e Avatar. Também inclui suporte ao MCP (Model Context Protocol) e tipos de protocolo para mensagens, bots e chamadas de ferramentas. Esta skill é útil porque padroniza a implementação de chat AI, garantindo que o mesmo código funcione perfeitamente em plataformas nativas e web, reduzindo significativamente o esforço de desenvolvimento e os bugs relacionados à concorrência.

Funciona com✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry/tree/HEAD/skills/ai-llm/molykit-galacticvraj-vraj-portfolio

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Habilidade MolyKit

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

Base de código fonte: /Users/zhangalex/Work/Projects/FW/robius/moly/moly-kit

Quando Usar

Use esta habilidade quando:

  • Construindo interfaces de chat AI com Makepad
  • Integrando OpenAI ou outras APIs LLM
  • Implementando funcionalidades assíncronas multiplataforma para nativo e WASM
  • Criando widgets de chat (mensagens, prompts, avatares)
  • Manipulando respostas de streaming SSE
  • Palavras-chave: molykit, moly-kit, chat ai, cliente bot, openai makepad, widget chat, streaming sse

Visão Geral

MolyKit fornece:

  • Utilitários assíncronos 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 ao MCP (Model Context Protocol)

Padrões Assíncronos Multiplataforma

PlatformSend - Enviar Apenas em Nativo

/// Implica Send apenas em plataformas nativas, não em WASM
/// - Em nativo: implementado por tipos que implementam Send
/// - Em WASM: implementado por TODOS os tipos
pub trait PlatformSend: PlatformSendInner {}

/// Tipo de future empacotado para uso multiplataforma
pub type BoxPlatformSendFuture<'a, T> = Pin<Box<dyn PlatformSendFuture<Output = T> + 'a>>;

/// Tipo de stream empacotado para uso multiplataforma
pub type BoxPlatformSendStream<'a, T> = Pin<Box<dyn PlatformSendStream<Item = T> + 'a>>;

Spawning Independente de Plataforma

/// Executa um future de forma independente
/// - Usa tokio em nativo (requer Send)
/// - Usa wasm-bindgen-futures em WASM (não requer Send)
pub fn spawn(fut: impl PlatformSendFuture<Output = ()> + 'static);

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

Cancelamento de Tarefas com AbortOnDropHandle

/// Handle que aborta seu future quando descartado
pub struct AbortOnDropHandle(AbortHandle);

// Uso - tarefa cancelada quando widget é descartado
#[rust]
task_handle: Option<AbortOnDropHandle>,

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

ThreadToken para Tipos Non-Send em WASM

/// Armazena valor non-Send em thread-local, acessa 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;
}

// Uso - encapsular tipo non-Send para uso em limites Send
let token = ThreadToken::new(non_send_value);
spawn(async move {
    token.peek(|value| {
        // usar valor...
    });
});

Trait BotClient

Implementando Integração com Provedor de IA

pub trait BotClient: Send {
    /// Envia mensagem com resposta em stream
    fn send(
        &mut self,
        bot_id: &BotId,
        messages: &[Message],
        tools: &[Tool],
    ) -> BoxPlatformSendStream<'static, ClientResult<MessageContent>>;

    /// Obtém bots/modelos disponíveis
    fn bots(&self) -> BoxPlatformSendFuture<'static, ClientResult<Vec<Bot>>>;

    /// Clone para passar adiante
    fn clone_box(&self) -> Box<dyn BotClient>;
}

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

BotContext - Invólucro Compartilhável

/// Invólucro compartilhável com bots carregados para acesso síncrono à UI
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>;
}

// Uso
let mut context = BotContext::from(client);
spawn(async move {
    if let Err(errors) = context.load().await.into_result() {
        // tratar erros
    }
    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
    pub citations: Vec<String>, // URLs de fontes
    pub attachments: Vec<Attachment>,
    pub tool_calls: Vec<ToolCall>,
    pub tool_results: Vec<ToolResult>,
}

pub struct MessageMetadata {
    pub is_writing: bool,       // Ainda está sendo transmitido
    pub created_at: DateTime<Utc>,
}

Identificação do Bot

/// ID de bot globalmente único: <len>;<id>@<provider>
pub struct BotId(Arc<str>);

impl BotId {
    pub fn new(id: &str, provider: &str) -> Self;
    pub fn id(&self) -> &str;       // id local do provedor
    pub fn provider(&self) -> &str; // domínio do provedor
}

// Exemplo: BotId::new("gpt-4", "api.openai.com")
// -> "5;[email protected]"

Padrões de Widget

Slot Widget - Substituição de Conteúdo em Tempo de Execução

live_design! {
    pub Slot = {{Slot}} {
        width: Fill, height: Fit,
        slot = <View> {}  // conteúdo padrão
    }
}

// Uso - substituir conteúdo em tempo de execução
let mut slot = widget.slot(id!(content));
if let Some(custom) = client.content_widget(cx, ...) {
    slot.replace(custom);
} else {
    slot.restore();  // voltar ao padrão
    slot.default().as_standard_message_content().set_content(cx, &content);
}

Avatar Widget - Alternância Texto/Imagem

live_design! {
    pub Avatar = {{Avatar}} <View> {
        grapheme = <RoundedView> {
            visible: false,
            label = <Label> { text: "P" }
        }
        dependency = <RoundedView> {
            visible: false,
            image = <Image> {}
        }
    }
}

impl Widget for Avatar {
    fn draw_walk(&mut self, cx: &mut Cx2d, ...) -> DrawStep {
        if let Some(avatar) = &self.avatar {
            match avatar {
                Picture::Grapheme(g) => {
                    self.view(id!(grapheme)).set_visible(cx, true);
                    self.view(id!(dependency)).set_visible(cx, false);
                    self.label(id!(label)).set_text(cx, &g);
                }
                Picture::Dependency(d) => {
                    self.view(id!(dependency)).set_visible(cx, true);
                    self.view(id!(grapheme)).set_visible(cx, false);
                    self.image(id!(image)).load_image_dep_by_path(cx, d.as_str());
                }
            }
        }
        self.deref.draw_walk(cx, scope, walk)
    }
}

Widget PromptInput

#[derive(Live, Widget)]
pub struct PromptInput {
    #[deref] deref: CommandTextInput,
    #[live] pub send_icon: LiveValue,
    #[live] pub stop_icon: LiveValue,
    #[rust] pub task: Task,           // Enviar ou Parar
    #[rust] pub interactivity: Interactivity,
}

impl PromptInput {
    pub fn submitted(&self, actions: &Actions) -> bool;
    pub fn reset(&mut self, cx: &mut Cx);
    pub fn set_send(&mut self);
    pub fn set_stop(&mut self);
    pub fn enable(&mut self);
    pub fn disable(&mut self);
}

Widget Messages - Visualização da Conversa

#[derive(Live, Widget)]
pub struct Messages {
    #[deref] deref: View,
    #[rust] pub messages: Vec<Message>,
    #[rust] pub bot_context: Option<BotContext>,
}

impl Messages {
    pub fn set_messages(&mut self, messages: Vec<Message>, scroll_to_bottom: bool);
    pub fn scroll_to_bottom(&mut self, cx: &mut Cx, triggered_by_stream: bool);
    pub fn is_at_bottom(&self) -> bool;
}

Padrão UiRunner para Assíncrono-para-UI

impl Widget for PromptInput {
    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
        self.deref.handle_event(cx, event, scope);
        self.ui_runner().handle(cx, event, scope, self);

        if self.button(id!(attach)).clicked(event.actions()) {
            let ui = self.ui_runner();
            Attachment::pick_multiple(move |result| match result {
                Ok(attachments) => {
                    ui.defer_with_redraw(move |me, cx, _| {
                        me.attachment_list_ref().write().attachments.extend(attachments);
                    });
                }
                Err(_) => {}
            });
        }
    }
}

Streaming SSE

/// Analisa stream de bytes SSE em stream de mensagens
pub fn parse_sse<S, B, E>(s: S) -> impl Stream<Item = Result<String, E>>
where
    S: Stream<Item = Result<B, E>>,
    B: AsRef<[u8]>,
{
    // Dividir em "\n\n", extrair conteúdo "data:"
    // Filtrar comentários e mensagens [DONE]
}

// Uso em BotClient::send
fn send(&mut self, ...) -> BoxPlatformSendStream<...> {
    let stream = stream! {
        let response = client.post(url).send().await?;
        let events = parse_sse(response.bytes_stream());

        for await event in events {
            let completion: Completion = serde_json::from_str(&event)?;
            content.text.push_str(&completion.delta.content);
            yield ClientResult::new_ok(content.clone());
        }
    };
    Box::pin(stream)
}

Melhores Práticas

  1. Use PlatformSend para multiplataforma: Mesmo código funciona em nativo e WASM
  2. Use spawn() não tokio::spawn: Spawning de tarefas independente de plataforma
  3. Use AbortOnDropHandle: Cancelar tarefas quando widget é descartado
  4. Use ThreadToken para non-Send em WASM: Armazenamento thread-local com acesso via token
  5. Use Slot para conteúdo personalizado: Permitir que BotClient forneça widgets personalizados
  6. Use padrão read()/write(): Acesso de empréstimo seguro via WidgetRef
  7. Use UiRunner::defer_with_redraw: Atualizar widget a partir de contexto assíncrono
  8. Trate ClientResult como sucesso parcial: Pode ter valor E erros

Arquivos de Referência

  • llms.txt - Referência completa da API MolyKit

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

majiayu000/claude-skill-registry

Builds, edit or validate Agent Skill through conversational discovery. Use when the user requests to "Create an Agent", "Optimize an Agent" or "Edit an Agent".

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad

majiayu000/claude-skill-registry

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry

Portfolio allocation and rebalancing optimizer. Manages asset allocation across stocks/cash/bonds, performs periodic rebalancing, and ensures diversification according to market regime and risk tolerance.

majiayu000/claude-skill-registry

Create a hilarious and ultra-realistic video of an anthropomorphic animal acting like a human vlogger in a real-world setting.

majiayu000/claude-skill-registry

Speech-to-text transcription and translation via OpenAI Audio API -- models, response formats, timestamps, prompting, streaming, chunking, and diarization

majiayu000/claude-skill-registry

BlockRun works with Claude Code and Google Antigravity.

majiayu000/claude-skill-registry

This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.

majiayu000/claude-skill-registry

小省导购员数字人带货版即梦视频提示词生成系统,基于四大智能体协同(提示词生成师、质量管控师、知识库运维师、跨环节适配师),按照"主体+运动+场景+(镜头语言+光影+氛围)"公式输出中英文双版提示词,适配5s短视频。确保人物一致性、视觉连贯性、情绪连贯性,支持知识库智能复用和跨工具适配(Suno音乐、AI绘画),为数字人带货视频提供高质量提示词生成服务。

majiayu000/claude-skill-registry

Upload and manage files using Google Gemini File API via scripts/. Use for uploading images, audio, video, PDFs, and other files for use with Gemini models. Supports file upload, status checking, and file management. Triggers on "upload file", "file API", "upload image", "upload PDF", "upload video", "file management".

majiayu000/claude-skill-registry

AI and machine learning workflow covering LLM application development, RAG implementation, agent architecture, ML pipelines, and AI-powered features.

majiayu000/claude-skill-registry

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry

Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]

majiayu000/claude-skill-registry

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Habilidades Relacionadas