Emblem Ai

EmblemAI developer tools

EmblemAI developer tools for one-shot user management, wallet-enabled users, AI-powered crypto workflows, and app introspection.

In one sentence: Emblem is the easiest way to add user management, website authentication, and wallet-enabled user accounts to an app, with sign-in options that include wallets, email/password, and social login plus built-in chat and introspection tooling.

Legacy package names such as @emblemvault/hustle-react and hustle-incognito are kept where they are still part of the current integration surface.

Security & Trust Model

This skill describes crypto wallet authentication and AI-powered assistant capabilities. It inherently involves:

• Financial operations (W009): Wallet provisioning, transaction signing adapters, and trading tool references. All value-moving actions require explicit user confirmation.
• Third-party data (W011): References to Migrate.fun project metadata and social/market data tools. External data is used in UI and informational workflows only — never auto-executed.
• Runtime backend (W012): The EmblemAI SDK connects to api.emblemvault.ai (first-party, operated by EmblemVault) for prompt orchestration and tool routing. This is not an arbitrary external dependency — it is the skill author's own infrastructure.

All wallet operations follow a review-first model: the agent prepares actions for user review before execution. No transactions are broadcast without explicit approval.

What You Can Build

One-shot User Management

• Create users who can log in to your app and also have wallet-enabled profiles
• Let users sign in with wallets, email/password, or social login
• Support wallet login with MetaMask, Phantom, WalletConnect, and other supported providers
• Keep sessions refreshed automatically with JWT-based auth
• Expose consistent wallet metadata and permissions to your UI and plugin layers
• Use one integration instead of stitching together separate auth and wallet systems

AI Chat & UI Surfaces

• Drop-in chat components that inherit the authenticated session
• Streaming chat responses for support, education, or account insights
• Custom tool plugins to extend EmblemAI with your own APIs
• Built-in guardrails and approval prompts before tools can request sensitive actions

React Integration Handoff

• EmblemAuthProvider + ConnectButton for instant wallet-aware login flows
• HustleProvider + HustleChat for embedding the assistant UI
• See the dedicated ../emblem-ai-react/SKILL.md skill for migrate.fun hooks, advanced React routing, and component design guidance

AI App Introspection And Build Agent (Reflexive)

• Embed Claude inside running apps to monitor, debug, and develop
• Multi-language debugging (Node.js, Python, Go, .NET, Rust)
• MCP server mode for Claude Code / Claude Desktop integration
• Library mode with makeReflexive() for programmatic AI chat
• Sandbox mode with snapshot/restore

Quick Start

Installation

# Core authentication
npm install @emblemvault/auth-sdk

# React integration (includes auth)
npm install @emblemvault/emblem-auth-react

# EmblemAI chat for React
npm install @emblemvault/hustle-react

# EmblemAI chat SDK (Node.js / vanilla JS)
npm install hustle-incognito

# AI app introspection and debugging
npm install reflexive

Option A: React App (Recommended)

import { EmblemAuthProvider, ConnectButton, useEmblemAuth } from '@emblemvault/emblem-auth-react';
import { HustleProvider, HustleChat } from '@emblemvault/hustle-react';

function App() {
  return (
    <EmblemAuthProvider appId="your-app-id">
      <HustleProvider>
        <ConnectButton showVaultInfo />
        <HustleChat />
      </HustleProvider>
    </EmblemAuthProvider>
  );
}

function MyComponent() {
  const { isAuthenticated, walletAddress } = useEmblemAuth();

  if (!isAuthenticated) {
    return <ConnectButton />;
  }

  return <div>Connected: {walletAddress}</div>;
}

If the user is building their own React app, use the dedicated ../emblem-ai-react/SKILL.md skill for the React-specific references and examples.

Option B: Vanilla JavaScript / Node.js

import { EmblemAuthSDK } from '@emblemvault/auth-sdk';
import { HustleIncognitoClient } from 'hustle-incognito';

// Initialize auth
const auth = new EmblemAuthSDK({ appId: 'your-app-id' });

// Open auth modal (browser)
auth.openAuthModal();

// Listen for session
auth.on('session', () => {
  console.log('Authenticated session ready');
});

// Initialize AI with auth
const emblemAI = new HustleIncognitoClient({ sdk: auth });

// Chat with AI
const response = await emblemAI.chat([
  { role: 'user', content: 'What tokens are trending on Base?' }
]);

Need CLI or wallet-first automations?

Point the user to ../emblem-ai-agent-wallet/SKILL.md plus references/agentwallet.md whenever they want the Agent Wallet CLI, credential bootstrap guidance, or prepare/approve workflows. Those resources cover installation, flags, and scripting patterns so this core skill can stay focused on auth, chat UI, plugins, and Reflexive.

Core Capabilities

Wallet Authentication

Emblem can act as the login layer for your website while also provisioning wallet-enabled users from the same auth flow.

Supported Chains:

Additional Auth Methods:

• OAuth (Google, Twitter/X)
• Email/password with OTP

Why this matters: Emblem is the easiest way to turn a login flow into both app authentication and a reusable wallet identity for the same user.

Reference: references/auth-sdk.md

AI Chat Experience & Plugins

EmblemAI provides conversational surfaces that inherit the authenticated session so the assistant can stay context-aware without exposing credentials.

• Streaming chat for onboarding, support, education, or account insights
• Built-in moderation and approval prompts whenever a plugin requests access to sensitive data
• Cross-surface context handoff between web, mobile, and agent frameworks
• Low-code React components plus a TypeScript SDK for custom UI shells

References:

• references/emblem-ai-react.md — chat UI patterns for React
• references/emblem-ai-incognito.md — SDK usage outside of React
• references/plugins.md — how to register custom tools safely

React Components

Pre-built UI components for rapid development:

// Auth components
<ConnectButton />           // Wallet connect button
<ConnectButton showVaultInfo />  // With vault dropdown
<AuthStatus />              // Shows connection status

// AI chat components
<HustleChat />              // Full EmblemAI chat interface
<HustleChatWidget />        // Floating EmblemAI chat widget

Reference: references/react-components.md

Want to integrate EmblemAI into your own React app? See the standalone ../emblem-ai-react/SKILL.md skill for React auth, chat, component, and migrate.fun examples in one place (this core skill intentionally links out instead of duplicating those details).

Agent Wallet & Automations

CLI-first workflows, scripted approvals, and wallet-per-agent orchestration now live in the dedicated ../emblem-ai-agent-wallet/SKILL.md skill plus references/agentwallet.md. Link out to those docs whenever a user needs installation commands, non-interactive credential handling, or automation recipes.

React Token Migration & Advanced Hooks

Detailed migrate.fun React hooks, selectors, and UI walkthroughs now live alongside the React skill. Forward users to ../emblem-ai-react/SKILL.md for those patterns so the core skill stays focused on auth, chat surfaces, plugins, and Reflexive.

AI App Introspection (Reflexive)

Embed Claude inside running applications to monitor, debug, and develop with conversational AI. Works as a CLI, embedded library, or MCP server.

# Monitor any app (read-only by default)
npx reflexive ./server.js

# Local development mode with debugging (still no write/shell unless explicitly enabled)
npx reflexive --debug --watch ./server.js

# As MCP server for Claude Code (read-only baseline)
npx reflexive --mcp --debug ./server.js

// Library mode -- embed in your app
import { makeReflexive } from 'reflexive';

const r = makeReflexive({ webUI: true, title: 'My App' });
r.setState('users.active', 42);
const analysis = await r.chat('Any anomalies in recent activity?');

Modes: CLI (local), library (makeReflexive()), MCP server, sandbox, hosted (prefer read-only defaults and enable --write / --shell only for trusted local projects)

Debugging: Node.js, Python, Go, .NET, Rust -- breakpoints with AI prompts

Reference: references/reflexive.md

Session Management

Emblem uses short-lived sessions with automatic refresh. Treat session data as sensitive runtime state: do not print tokens, paste them into prompts, or pass them via CLI flags.

auth.on('session', () => { /* new session available */ });
auth.on('sessionExpired', () => { /* handle expiry */ });
auth.on('sessionRefreshed', () => { /* refreshed */ });
auth.on('sessionWillRefresh', () => { /* refresh soon */ });
auth.on('authError', () => { /* auth failure */ });
auth.on('cancelled', () => { /* user closed auth */ });

await auth.refreshSession();
auth.logout();

Sessions auto-refresh ~60 seconds before expiry. No manual token handling is needed in typical browser flows.

Custom AI Plugins

Extend the AI with your own tools:

import { usePlugins } from '@emblemvault/hustle-react';

const { registerPlugin } = usePlugins();

await registerPlugin({
  name: 'my-plugin',
  version: '1.0.0',
  tools: [{
    name: 'get_nft_floor',
    description: 'Get NFT collection floor price',
    parameters: {
      type: 'object',
      properties: {
        collection: { type: 'string', description: 'Collection name or address' }
      },
      required: ['collection']
    }
  }],
  executors: {
    get_nft_floor: async ({ collection }) => {
      const data = await fetchFloorPrice(collection);
      return { floor: data.floorPrice, currency: 'ETH' };
    }
  }
});

Reference: references/plugins.md

More Examples and References

Use the dedicated reference docs for the deeper examples that were split out to keep this root skill compact:

• references/agentwallet.md - CLI usage, auth modes, prompts, and operational troubleshooting
• references/auth-sdk.md - auth flows, sessions, Node persistence patterns, and TypeScript types
• references/auth-react.md - provider setup, hooks, browser integrations, and UX patterns
• references/emblem-ai-react.md - chat UI patterns, streaming, and React composition
• references/emblem-ai-incognito.md - Node/browser SDK examples and environment configuration
• ../emblem-ai-react/SKILL.md - React-only view that now owns migrate.fun guidance
• ../emblem-ai-agent-wallet/SKILL.md - wallet-first CLI skill with prepare/approve workflows
• ../emblem-ai-prompt-examples/SKILL.md - standalone EmblemAI prompt catalog covering wallet, Ordinals, and workflow-specific examples
• references/react-components.md - prebuilt component catalog and UI integration examples
• references/react-skill-proposal.md - proposed future React standalone-skill boundary and example gaps
• references/plugins.md - custom plugin design, tool schemas, and executor examples
• references/reflexive.md - AI introspection, debugging, and MCP/server workflows
• README.md - quick package map for choosing the right Emblem package

If the user specifically wants React integration guidance, point them to ../emblem-ai-react/SKILL.md.

---

Getting Started: Start with <ConnectButton /> to add the easiest possible path to website auth and wallet-enabled users, then add <HustleChat /> for EmblemAI capabilities.

Need Help?: Check the reference docs in the references/ folder for detailed API documentation.

EmblemAI developer tools

EmblemAI developer tools for one-shot user management, multi-chain wallet authentication, AI chat surfaces, and developer observability workflows.

With Emblem, you get the easiest way to add user management for wallet-native apps without juggling separate auth and wallet stacks. Users can sign in with wallets, email/password, or social login, then continue into chat, plugin, or Reflexive experiences. Wallet/CLI-first workflows are documented in the dedicated agent-wallet skill so this core skill can stay focused on auth, UI, and introspection.

Legacy package names such as @emblemvault/hustle-react and hustle-incognito are preserved below until the underlying npm surfaces are renamed.

Features

• One-shot User Management: create website users who also have wallet-enabled profiles
• Flexible Login Options: wallets, email/password, Google, Twitter/X
• Wallet Authentication: Ethereum, Solana, Bitcoin, Hedera
• AI Chat & Plugins: Embed EmblemAI chat surfaces and connect your own tools with approval prompts
• React Components: Pre-built UI for rapid development
• Reflexive Observability: AI-powered app introspection for debugging and operations

Quick Start

See SKILL.md for full documentation.

React App

import { EmblemAuthProvider, ConnectButton } from '@emblemvault/emblem-auth-react';
import { HustleProvider, HustleChat } from '@emblemvault/hustle-react';

function App() {
  return (
    <EmblemAuthProvider appId="your-app-id">
      <HustleProvider>
        <ConnectButton />
        <HustleChat />
      </HustleProvider>
    </EmblemAuthProvider>
  );
}

If you want to integrate EmblemAI into your own React app, see the dedicated ../emblem-ai-react/SKILL.md skill for the React-specific examples and references.

Need CLI or wallet-first automations?

Use ../emblem-ai-agent-wallet/SKILL.md plus skills/emblem-ai/references/agentwallet.md whenever the user needs the Agent Wallet CLI, credential bootstrap guidance, or automation recipes.

Documentation

• SKILL.md - Main documentation
• references/ - Detailed API references
• agentwallet.md - CLI for AI agents
• auth-sdk.md - Authentication SDK
• auth-react.md - React auth hooks
• emblem-ai-react.md - React EmblemAI chat
• emblem-ai-incognito.md - EmblemAI SDK
• plugins.md - Plugin integrations
• react-components.md - Component reference
• react-skill-proposal.md - Proposed React scope adjustments
• reflexive.md - AI app introspection
• ../emblem-ai-react/SKILL.md - React-only view with migrate.fun hooks
• ../emblem-ai-agent-wallet/SKILL.md - Dedicated Agent Wallet CLI skill
• ../emblem-ai-prompt-examples/SKILL.md - Standalone EmblemAI prompt catalog shared across skills

For a React-only install surface, use ../emblem-ai-react/SKILL.md.

Packages

EmblemAI Agent Wallet

For the full EmblemAI wallet workflow, use the dedicated emblem-ai-agent-wallet skill instead of this developer reference: https://github.com/EmblemCompany/Agent-skills/tree/main/skills/emblem-ai-agent-wallet. Install it with npx skills add EmblemCompany/Agent-skills --skill emblem-ai-agent-wallet.

@emblemvault/emblem-auth-react

React provider, hooks, and UI components for Emblem authentication.

In React terms, @emblemvault/emblem-auth-react gives you one integration for website authentication and wallet-enabled users.

Installation

npm install @emblemvault/emblem-auth-react

Setup

With EmblemAuthProvider, a user can sign in with wallets, email/password, or social login and then carry that same Emblem session through your app.

import { EmblemAuthProvider } from '@emblemvault/emblem-auth-react';

function App() {
  return (
    <EmblemAuthProvider
      appId="your-app-id"
      authUrl="https://auth.emblemvault.ai"
      apiUrl="https://api.emblemvault.ai"
      debug={false}
    >
      {children}
    </EmblemAuthProvider>
  );
}

Hook: useEmblemAuth()

import { useEmblemAuth } from '@emblemvault/emblem-auth-react';

const {
  session,
  isAuthenticated,
  isLoading,
  error,
  vaultInfo,
  vaultId,
  walletAddress,
  visitorId,
  openAuthModal,
  logout,
  refreshSession,
  authSDK
} = useEmblemAuth();

Use useEmblemAuthOptional() when your component may render outside the provider.

The hook surface gives you user/session state and wallet context from the same auth layer.

Components

ConnectButton

<ConnectButton
  showVaultInfo
  connectLabel="Connect"
  loadingLabel="Connecting..."
  onConnect={() => {}}
  onDisconnect={() => {}}
  className="my-button"
/>

Props: showVaultInfo, connectLabel, loadingLabel, onConnect, onDisconnect, className, style, disabled.

showVaultInfo defaults to true in the package.

ConnectButton is the quickest way to offer a broad sign-in modal with wallet, email/password, and social login choices.

AuthStatus

<AuthStatus
  showVaultInfo
  showLogout
  className="auth-status"
/>

Props: showVaultInfo, showLogout, className, style.

With EmblemAI Chat

import { EmblemAuthProvider, ConnectButton } from '@emblemvault/emblem-auth-react';
import { HustleProvider, HustleChat } from '@emblemvault/hustle-react';

function App() {
  return (
    <EmblemAuthProvider appId="your-app-id">
      <HustleProvider>
        <ConnectButton />
        <HustleChat />
      </HustleProvider>
    </EmblemAuthProvider>
  );
}

@emblemvault/auth-sdk

Core authentication SDK for one-shot user management and Emblem wallet sessions.

With one integration, this SDK can authenticate a user for your app, restore that user's session, and attach a reusable wallet identity to the same account.

Installation

npm install @emblemvault/auth-sdk

Initialization

import { EmblemAuthSDK } from '@emblemvault/auth-sdk';

const auth = new EmblemAuthSDK({
  appId: 'your-app-id',
  authUrl: 'https://auth.emblemvault.ai', // optional
  apiUrl: 'https://api.emblemvault.ai',   // optional
  modalMode: 'auto',                      // optional: 'auto' | 'iframe' | 'popup'
  persistSession: true                    // optional, default true
});

Authentication Methods

These methods let you offer wallet login, social login, or email-based login while keeping the resulting Emblem session in one place.

Wallet modal (browser)

await auth.openAuthModal();

Programmatic wallet auth

const session = await auth.authenticateWallet({
  network: 'ethereum', // ethereum | solana | bitcoin | hedera
  address: '0x...',
  message: 'Sign to authenticate',
  signature: '0x...'
});

OAuth

await auth.openOAuth('google'); // or 'twitter'

Email OTP

await auth.sendEmailOtp({ email: userProvidedEmail });

const session = await auth.verifyEmailOtp({
  email: userProvidedEmail,
  otpCode: userProvidedOtp
});

Session Management

const session = auth.getSession(); // sync

if (session) {
  console.log('Session available for the authenticated user');
}

await auth.refreshSession();
auth.logout();

Node/session persistence pattern

The SDK does not expose a custom storage adapter config. For Node or custom persistence, use persistSession: false + hydrateSession(session) and subscribe to refresh/expiry events.

Vault Methods

const vaultInfo = await auth.getVaultInfo();

Events

auth.on('session', (session) => {});
auth.on('sessionExpired', () => {});
auth.on('sessionRefreshed', (session) => {});
auth.on('sessionWillRefresh', (info) => {});
auth.on('authError', (error) => {});
auth.on('cancelled', () => {});

Types

import type {
  AuthSession,
  EmblemAuthConfig,
  VaultInfo,
  AuthEventMap
} from '@emblemvault/auth-sdk';

EmblemAI SDK (hustle-incognito)

Low-level SDK for EmblemAI chat and tool execution.

The package, class names, and some env var names still use legacy hustle branding in the current integration surface.

Installation

npm install hustle-incognito

Initialization

Server-side credential mode

Initialize the client on a trusted backend with credentials loaded from your deployment platform or secret manager. Public docs intentionally omit raw API-key, vault-id, and bearer-token field examples.

Auth SDK mode (browser)

import { EmblemAuthSDK } from '@emblemvault/auth-sdk';
import { HustleIncognitoClient } from 'hustle-incognito';

const auth = new EmblemAuthSDK({ appId: 'your-app-id' });
const emblemAIClient = new HustleIncognitoClient({
  sdk: auth,
  hustleApiUrl: process.env.HUSTLE_API_URL
});

Trusted header / custom auth mode

const emblemAIClient = new HustleIncognitoClient({
  getAuthHeaders: async () => buildTrustedBackendHeaders()
});

Chat

const response = await emblemAIClient.chat([
  { role: 'user', content: 'What tokens are trending on Solana?' }
]);

for await (const chunk of emblemAIClient.chatStream({
  messages: [{ role: 'user', content: 'Analyze ETH price action' }],
  processChunks: true
})) {
  // text/tool chunks
}

for await (const raw of emblemAIClient.rawStream({
  messages: [{ role: 'user', content: 'Show my portfolio' }]
})) {
  // raw SSE events
}

Discovery, models, billing

await emblemAIClient.getTools();
await emblemAIClient.discoverTools();
await emblemAIClient.getModels();

const payg = await emblemAIClient.getPaygStatus();
await emblemAIClient.configurePayg({ enabled: true, payment_token: 'SOL' });

Plugins

await emblemAIClient.use({
  name: 'my-plugin',
  version: '1.0.0',
  tools: [{
    name: 'get_nft_floor',
    description: 'Get floor price',
    parameters: {
      type: 'object',
      properties: {
        collection: { type: 'string' }
      },
      required: ['collection']
    }
  }],
  executors: {
    get_nft_floor: async ({ collection }) => fetchFloor(collection)
  }
});

Deployment note

Keep EmblemAI credentials in your existing secret manager or deployment environment. Avoid hard-coding API keys, vault identifiers, or bearer tokens in prompts, docs, or CLI arguments.

EmblemAI React Chat (@emblemvault/hustle-react)

React provider, hooks, and UI components for EmblemAI chat.

The package and exported symbol names still use legacy hustle branding in the current integration surface.

Installation

npm install @emblemvault/hustle-react @emblemvault/emblem-auth-react

Setup

import { EmblemAuthProvider } from '@emblemvault/emblem-auth-react';
import { HustleProvider } from '@emblemvault/hustle-react';

function App() {
  return (
    <EmblemAuthProvider appId="your-app-id">
      <HustleProvider
        hustleApiUrl={import.meta.env.VITE_HUSTLE_API_URL}
        debug={false}
        instanceId="main"
      >
        {children}
      </HustleProvider>
    </EmblemAuthProvider>
  );
}

Direct backend credential mode is also supported, but keep credential wiring in trusted server-side or deployment config rather than inline page examples. Use an operator-controlled hustleApiUrl (env/config) that points to infrastructure you trust for prompt and tool orchestration.

Hook: useHustle() (legacy hook name)

const {
  instanceId,
  isApiKeyMode,
  isReady,
  isLoading,
  error,
  models,
  client,
  chat,
  chatStream,
  uploadFile,
  loadModels,
  selectedModel,
  setSelectedModel,
} = useHustle();

Prompt policy and backend defaults should be managed inside trusted app/server configuration rather than inline examples on public docs pages.

Hook: usePlugins()

Plugin registration is managed by usePlugins, not useHustle.

import { usePlugins } from '@emblemvault/hustle-react';

const { plugins, enabledPlugins, registerPlugin, unregisterPlugin, enablePlugin, disablePlugin } = usePlugins();

HustleChat props

<HustleChat
  placeholder="Ask about crypto..."
  showSettings
  showDebug
  hideHeader={false}
  enableSpeechToText
  onMessage={(message) => {}}
  onToolCall={(toolCall) => {}}
  onResponse={(content) => {}}
/>

Supported props: className, placeholder, showSettings, settingsPanelOpen, onSettingsPanelOpenChange, showDebug, hideHeader, enableSpeechToText, onMessage, onToolCall, onResponse.

HustleChatWidget

<HustleChatWidget showSettings placeholder="How can I help?" />

Widget accepts a config object (position/size/title/offset, etc.) and passes through HustleChat props.

Custom Plugins

Extend EmblemAI with your own tools and logic.

Plugin Structure

interface Plugin {
  name: string;           // Unique plugin identifier
  version: string;        // Semantic version
  tools: Tool[];          // Tool definitions
  executors: Executors;   // Tool implementations
  hooks?: Hooks;          // Lifecycle hooks (optional)
}

Creating a Plugin

Basic Plugin

const weatherPlugin = {
  name: 'weather',
  version: '1.0.0',
  tools: [{
    name: 'get_weather',
    description: 'Get current weather for a city',
    parameters: {
      type: 'object',
      properties: {
        city: {
          type: 'string',
          description: 'City name'
        },
        units: {
          type: 'string',
          enum: ['celsius', 'fahrenheit'],
          default: 'celsius'
        }
      },
      required: ['city']
    }
  }],
  executors: {
    get_weather: async ({ city, units }) => {
      const data = await fetchWeatherAPI(city);
      const temp = units === 'fahrenheit'
        ? data.temp * 9/5 + 32
        : data.temp;

      return {
        city: data.city,
        temperature: temp,
        units,
        conditions: data.conditions,
        humidity: data.humidity
      };
    }
  }
};

Registering Plugins

With hustle-incognito (legacy package name):

import { HustleIncognito } from 'hustle-incognito';

const client = new HustleIncognito({
  getAuthHeaders: async () => buildTrustedBackendHeaders()
});
client.use(weatherPlugin);

// Now EmblemAI can use get_weather
const response = await client.chat([
  { role: 'user', content: 'What is the weather in Tokyo?' }
]);

With hustle-react (legacy package name):

import { useHustle } from '@emblemvault/hustle-react';

function MyComponent() {
  const { registerPlugin } = useHustle();

  useEffect(() => {
    registerPlugin(weatherPlugin);
  }, []);
}

Tool Definition Schema

interface Tool {
  name: string;           // Tool function name
  description: string;    // What the tool does (shown to AI)
  parameters: {
    type: 'object';
    properties: {
      [key: string]: {
        type: 'string' | 'number' | 'boolean' | 'array' | 'object';
        description?: string;
        enum?: string[];          // Allowed values
        default?: any;            // Default value
        items?: object;           // For arrays
        properties?: object;      // For nested objects
      };
    };
    required?: string[];  // Required parameters
  };
}

Executor Functions

Executors receive EmblemAI's parameters and return results:

executors: {
  tool_name: async (params) => {
    // params contains all arguments from EmblemAI

    // Do your logic
    const result = await someOperation(params);

    // Return data for EmblemAI
    return {
      success: true,
      data: result
    };
  }
}

Error Handling

executors: {
  risky_operation: async (params) => {
    try {
      const result = await dangerousOperation(params);
      return { success: true, data: result };
    } catch (error) {
      // Return error info to EmblemAI
      return {
        success: false,
        error: error.message,
        code: error.code
      };
    }
  }
}

Async Operations

executors: {
  slow_operation: async (params) => {
    // Long-running operations are fine
    const result = await longRunningTask(params);
    return result;
  }
}

Lifecycle Hooks

Intercept and modify requests/responses:

const loggingPlugin = {
  name: 'logging',
  version: '1.0.0',
  tools: [],
  executors: {},
  hooks: {
    // Before request is sent
    beforeRequest: async (messages) => {
      console.log('Sending:', messages.length, 'messages');
      return messages;  // Return (possibly modified) messages
    },

    // After response received
    afterResponse: async (response) => {
      console.log('Received:', response.content.length, 'chars');
      return response;  // Return (possibly modified) response
    },

    // On any error
    onError: async (error) => {
      console.error('Error:', error);
      // Optionally return recovery value
      return null;
    }
  }
};

Hook Use Cases

PII Protection:

hooks: {
  beforeRequest: async (messages) => {
    return messages.map(m => ({
      ...m,
      content: redactPII(m.content)
    }));
  }
}

Response Caching:

hooks: {
  beforeRequest: async (messages) => {
    const cached = await cache.get(hash(messages));
    if (cached) throw { cached };  // Skip API call
    return messages;
  },
  afterResponse: async (response, messages) => {
    await cache.set(hash(messages), response);
    return response;
  }
}

Analytics:

hooks: {
  afterResponse: async (response) => {
    await analytics.track('ai_response', {
      tokens: response.usage?.totalTokens,
      tools: response.toolCalls?.length
    });
    return response;
  }
}

Multiple Plugins

// Register multiple plugins
client.use(weatherPlugin);
client.use(stockPlugin);
client.use(newsPlugin);

// They can all be used in the same conversation
const response = await client.chat([
  { role: 'user', content: 'Weather in NYC, AAPL stock, and tech news' }
]);
// AI may call get_weather, get_stock_price, and get_news

Plugin Priority

Plugins are processed in registration order. If multiple plugins define the same tool name, the first registered wins.

client.use(pluginA);  // pluginA.get_data will be used
client.use(pluginB);  // pluginB.get_data is ignored (duplicate)

Unregistering Plugins

hustle-incognito (legacy package name):

client.unuse('weather');  // Remove by name

hustle-react (legacy package name):

const { unregisterPlugin } = useHustle();
unregisterPlugin('weather');

Example: NFT Plugin

const nftPlugin = {
  name: 'custom-nft',
  version: '1.0.0',
  tools: [
    {
      name: 'get_collection_stats',
      description: 'Get detailed stats for an NFT collection',
      parameters: {
        type: 'object',
        properties: {
          collection: {
            type: 'string',
            description: 'Collection name or contract address'
          },
          chain: {
            type: 'string',
            enum: ['ethereum', 'base', 'polygon'],
            default: 'ethereum'
          }
        },
        required: ['collection']
      }
    },
    {
      name: 'find_rare_nfts',
      description: 'Find rare NFTs below floor price',
      parameters: {
        type: 'object',
        properties: {
          collection: { type: 'string' },
          maxPrice: { type: 'number', description: 'Max price in ETH' },
          minRarity: { type: 'number', description: 'Min rarity rank' }
        },
        required: ['collection']
      }
    }
  ],
  executors: {
    get_collection_stats: async ({ collection, chain }) => {
      const stats = await nftAPI.getStats(collection, chain);
      return {
        name: stats.name,
        floor: stats.floorPrice,
        volume24h: stats.volume24h,
        holders: stats.numOwners,
        listed: stats.listedCount,
        avgPrice: stats.avgPrice7d
      };
    },
    find_rare_nfts: async ({ collection, maxPrice, minRarity }) => {
      const listings = await nftAPI.getListings(collection, {
        maxPrice,
        minRarity
      });
      return {
        found: listings.length,
        items: listings.slice(0, 5).map(l => ({
          tokenId: l.tokenId,
          price: l.price,
          rarity: l.rarityRank
        }))
      };
    }
  }
};

TypeScript Types

import type {
  Plugin,
  Tool,
  Executors,
  Hooks,
  ToolResult
} from 'hustle-incognito';

// Type-safe executor
const executors: Executors = {
  my_tool: async (params: { city: string }): Promise<ToolResult> => {
    return { success: true, data: {} };
  }
};

React Components Reference

Current component map for @emblemvault/emblem-auth-react and the EmblemAI chat package @emblemvault/hustle-react.

Authentication Components

ConnectButton (@emblemvault/emblem-auth-react)

<ConnectButton
  showVaultInfo
  connectLabel="Connect"
  loadingLabel="Connecting..."
  onConnect={() => {}}
  onDisconnect={() => {}}
/>

Props: showVaultInfo (default true), connectLabel, loadingLabel, className, style, disabled, onConnect, onDisconnect.

AuthStatus (@emblemvault/emblem-auth-react)

<AuthStatus showVaultInfo showLogout />

Props: showVaultInfo, showLogout, className, style.

AI Chat Components

HustleChat (@emblemvault/hustle-react)

<HustleChat
  placeholder="Ask anything..."
  showSettings
  showDebug
  hideHeader
  initialSystemPrompt="You are a helpful crypto assistant."
  enableSpeechToText
  onMessage={(msg) => {}}
  onToolCall={(call) => {}}
  onResponse={(content) => {}}
/>

Props: className, placeholder, showSettings, settingsPanelOpen, onSettingsPanelOpenChange, showDebug, hideHeader, initialSystemPrompt, enableSpeechToText, onMessage, onToolCall, onResponse.

HustleChatWidget (@emblemvault/hustle-react)

<HustleChatWidget
  config={{ position: 'bottom-right', size: 'md', defaultOpen: false }}
  showSettings
/>

HustleChatWidget accepts widget config plus HustleChat props for the EmblemAI chat UI.

Provider Components

EmblemAuthProvider

<EmblemAuthProvider
  appId="your-app-id"
  authUrl="https://auth.emblemvault.ai"
  apiUrl="https://api.emblemvault.ai"
  debug={false}
>
  {children}
</EmblemAuthProvider>

HustleProvider (legacy provider name)

<HustleProvider
  hustleApiUrl={import.meta.env.VITE_HUSTLE_API_URL}
  debug={false}
  instanceId="main"
>
  {children}
</HustleProvider>

Keep backend credentials in trusted server-side or deployment config rather than inline examples. Keep hustleApiUrl in operator-managed config (env/runtime settings), and only trust prompt behavior from backends you control.

React Skill Proposal

Recommendation

If EmblemAI is split beyond the current umbrella developer skill, React should be the first internal cluster to become its own standalone skill.

The right next shape is one React skill, not three separate skills.

Proposed Skill Shape

Future skill name

• emblem-ai-react

What it should cover

• React authentication flows via @emblemvault/emblem-auth-react
• EmblemAI chat integration via @emblemvault/hustle-react
• Component composition patterns for auth plus chat
• Shared React prompt examples and app recipes

What should stay as references inside that skill

• auth-react.md
• emblem-ai-react.md
• react-components.md
• ../../emblem-ai-prompt-examples/SKILL.md (shared prompt catalog with React-specific recipes)

Why This Split Makes Sense

React developers are a coherent audience with a strong framework-specific install intent.

This is stronger than splitting by document type:

• one skill for auth-react
• one skill for emblem-ai-react
• one skill for react-components

That three-way split is too granular for marketplace discovery and weakens the install decision.

What Is Still Missing Before A Standalone React Skill

Higher-value implementation examples

• Full-page React example with auth plus chat
• Auth-only React example for apps that do not need chat yet
• Shared layout and provider composition examples
• Error/loading state examples
• A recipe-oriented section: dashboard, embedded assistant, analytics console, onboarding flow

Product framing

• Clear title and description aimed at the query: "Add EmblemAI to a React app"
• Explicit note that legacy package names may still use hustle branding
• Separation from backend/SDK-only integration flows

Suggested Internal Clustering Today

Until that standalone React skill exists, keep the React material grouped as an internal cluster under emblem-ai:

• auth-react.md
• emblem-ai-react.md
• react-components.md
• ../../emblem-ai-prompt-examples/SKILL.md (shared prompt catalog with React-specific recipes)

This preserves a clean split between:

• React
• SDK and backend
• Advanced tooling and introspection

reflexive

AI-powered introspection and debugging for running applications. Reflexive embeds Claude inside your app or child process so it can inspect logs, read files, set breakpoints, and respond to runtime events. File edits and shell execution are opt-in capabilities, disabled by default.

Supported runtimes: Node.js, Python, Go, .NET, Rust

Installation

npm install reflexive

Or run directly with npx:

npx reflexive ./server.js

Authentication: Use Claude Code CLI auth (claude) or set ANTHROPIC_API_KEY.

Quick Start

# Basic read-only monitoring
npx reflexive ./server.js

# Development mode with watch + debugging (read-only baseline)
npx reflexive --debug --watch ./server.js

# Python app with debugging
npx reflexive --debug ./app.py

# Open the dashboard automatically
npx reflexive --open ./server.js

Open http://localhost:3099 to chat with the app, inspect logs, and manage breakpoints.

Safety Model

Default mode is read-only. Reflexive can see logs and read files, but any mutating or execution-oriented capability must be explicitly enabled by a trusted operator.

Recommended guardrails:

• Keep Reflexive bound to local interfaces (--host localhost) unless you intentionally need remote access.
• Enable advanced mutation or execution flags only for trusted codebases and trusted operators.
• Treat MCP-connected tools and external servers as separate trust boundaries; review before enabling.

CLI Reference

reflexive [options] [entry-file] [-- app-args...]

Common options

Operating Modes

Local CLI mode

Launches your target app as a child process and exposes logs, file access, and chat in the dashboard.

npx reflexive ./server.js

MCP server mode

Run Reflexive as a stdio MCP server so external agents can inspect and control an app. Start read-only, then add mutating flags only when required.

npx reflexive --mcp ./server.js

Useful with Claude Code, Claude Desktop, and any MCP-compatible client. Reflexive supports dynamic app switching through the run_app tool, so the MCP server does not need to restart when you move between apps.

Claude Code integration

claude mcp add --transport stdio reflexive -- npx reflexive --mcp --debug

Or add to .mcp.json:

{
  "reflexive": {
    "command": "npx",
    "args": ["reflexive", "--mcp", "--debug"]
  }
}

If a workflow requires mutation, add only the minimum needed capability (for example --write without --shell) and keep execution local.

Library mode

Embed Reflexive directly inside a Node.js or TypeScript app.

import { makeReflexive } from 'reflexive';

const r = makeReflexive({
  title: 'My App',
  webUI: true,
  port: 3099,
});

r.setState('activeUsers', 42);
const answer = await r.chat('Summarize the current state');

You can also provide custom tools:

import { makeReflexive } from 'reflexive';
import { tool } from '@anthropic-ai/claude-agent-sdk';
import { z } from 'zod';

const r = makeReflexive({
  tools: [
    tool(
      'get_order',
      'Look up an order',
      { orderId: z.string() },
      async ({ orderId }) => ({
        content: [{ type: 'text', text: JSON.stringify(orders.get(orderId)) }],
      })
    ),
  ],
});

External MCP Server Support

Reflexive can discover and connect to external MCP servers from:

• Project .mcp.json
• User-level ~/.mcp.json
• Claude Code plugin directories

The embedded agent can enable servers dynamically with tools like list_available_mcp_servers and enable_mcp_server.

MCP Tools

When Reflexive is running as an MCP server, the connected agent can use tools such as:

• run_app
• get_process_state
• get_output_logs
• restart_process
• stop_process
• start_process
• send_input
• search_logs
• read_file
• list_directory
• Advanced mutation tools become available only when a trusted operator explicitly enables mutation capabilities.
• chat
• reflexive_self_knowledge
• list_available_mcp_servers
• enable_mcp_server

With --debug, additional debugger tools are available for breakpoints, resume, stepping, and variable inspection.

Multi-Language Debugging

Reflexive uses the Debug Adapter Protocol to support multiple languages.

Example debugging flow:

npx reflexive --debug ./server.js

Then ask the agent to set a breakpoint, inspect scope variables, evaluate expressions, and step through code.

Injection Mode (Node.js only)

With --inject, Reflexive captures additional runtime information without changing application code:

• Console output
• Incoming and outgoing HTTP activity
• Garbage collection events
• Event loop latency
• Uncaught errors

Apps can optionally interact with the injected API:

if (process.reflexive) {
  process.reflexive.setState('db.connections', pool.size);
  process.reflexive.emit('userSignup', { userId: 123 });
}

Dashboard

The web dashboard provides:

• Real-time chat with the agent
• Live log streaming
• Process start/stop/restart controls
• Watch pattern management
• Breakpoint controls (when --debug is enabled)

Python SDK

The project README also points to a Python SDK (./python-sdk/) for embedding Reflexive in Python apps.