### Paginate Through All Agents (Bash)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/xgate-server/skills/xgate-server.md

Demonstrates how to paginate through the list of agents using offset-based pagination. The first example fetches the initial set of agents, and the second example shows how to retrieve the subsequent page by adjusting the `offset` parameter.

```bash
# First page
curl -s "https://xgate.run/agents?limit=50&offset=0" | jq

# Next page
curl -s "https://xgate.run/agents?limit=50&offset=50" | jq
```

--------------------------------

### JavaScript Handler Code Examples

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agent-creator/skills/SKILL.md

Examples of JavaScript handler code for Lucid agents. These demonstrate basic echoing, extracting specific fields from input, and making network requests using the fetch API. Note that network access requires `handlerConfig.network.allowedHosts` to be set.

```javascript
return { echoed: input };
```

```javascript
return { text: input.text };
```

```javascript
const res = await fetch(`https://api.example.com/data?q=${encodeURIComponent(input.q)}`);
const data = await res.json();
return data;
```

--------------------------------

### Install GitHub CLI

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/railway-deploy/skills/SKILL.md

Installs the GitHub CLI tool, which is required for creating and managing GitHub repositories. Supports macOS and Ubuntu.

```bash
# macOS
brew install gh
# Ubuntu
sudo apt install gh

# Authenticate with GitHub
gh auth login
```

--------------------------------

### Install Prerequisites and Authenticate CLIs

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/agent-factory/skills/SKILL.md

Installs necessary runtime and command-line interface tools for agent creation and deployment. It includes steps for authenticating with GitHub and Railway, and setting essential environment variables for API keys and payment addresses.

```bash
# Runtime
curl -fsSL https://bun.sh/install | bash

# CLIs
npm install -g @railway/cli @anthropics/bird
brew install gh  # or apt install gh

# Authenticate
gh auth login
railway login

# Set credentials
export RAILWAY_TOKEN="<your-token>"
export PAYMENTS_RECEIVABLE_ADDRESS="<your-wallet>"
export AUTH_TOKEN="<twitter-auth-token>"  # optional
export CT0="<twitter-ct0>"  # optional
```

--------------------------------

### Run CLI with Adapter Selection (Bash)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Examples of how to run the Lucid Agents CLI and specify a web server adapter. Supported adapters include 'hono', 'express', 'tanstack-ui' (for a full dashboard), and 'tanstack-headless' (for API-only).

```bash
# Hono adapter
bunx @lucid-agents/cli my-agent --adapter=hono

# Express adapter
bunx @lucid-agents/cli my-agent --adapter=express

# TanStack UI (full dashboard)
bunx @lucid-agents/cli my-agent --adapter=tanstack-ui

# TanStack Headless (API only)
bunx @lucid-agents/cli my-agent --adapter=tanstack-headless
```

--------------------------------

### Moltbook API Key Setup (Bash)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/moltbook-promotion/skills/SKILL.md

This snippet demonstrates how to set up Moltbook API credentials by exporting the API key from a JSON configuration file into an environment variable. It requires the `curl` command-line tool.

```bash
# ~/.config/moltbook/credentials.json
# {
#   "api_key": "moltbook_sk_...",
#   "agent_name": "your_agent_name"
# }

export MOLTBOOK_API_KEY=$(cat ~/.config/moltbook/credentials.json | grep api_key | cut -d'"' -f4)
```

--------------------------------

### Install Lucid Agent Creator Skill (Claude CLI)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agent-creator/skills/GUIDE.md

Commands to add the skills-market plugin and install the lucid-agent-creator skill for Claude CLI. This skill enables the agent to understand the JS handler code contract and the `create_lucid_agent` MCP tool.

```bash
/plugin marketplace add daydreamsai/skills-market
/plugin install lucid-agent-creator@daydreams-skills
```

--------------------------------

### Install Daydreams Skills Market Plugin

Source: https://github.com/daydreamsai/skills-market/blob/main/README.md

Commands to add the Daydreams Skills Market to your local plugin marketplace and install specific skills. This is the entry point for using the skills provided by the market.

```bash
/plugin marketplace add daydreamsai/skills-market
/plugin install <skill-name>@daydreams-skills
```

--------------------------------

### Install Bird CLI for X/Twitter

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/trend-discovery/skills/SKILL.md

Installs the Bird CLI, a tool for interacting with X/Twitter data, which is optional but recommended for trend discovery. It also shows how to set authentication tokens.

```bash
# Bird CLI for X/Twitter (optional but recommended)
npm install -g @anthropics/bird

# Set X cookies for bird
export AUTH_TOKEN="your-twitter-auth-token"
export CT0="your-twitter-ct0"
```

--------------------------------

### Configure xgate MCP Server for Claude

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agent-creator/skills/GUIDE.md

Configuration snippet for `~/.claude.json` or project `.mcp.json` to add the xgate MCP server. Requires MCP URL and session token obtained from xgate.

```json
{
  "mcpServers": {
    "xgate": {
      "url": "YOUR_MCP_URL",
      "headers": {
        "Authorization": "Bearer YOUR_SESSION_TOKEN"
      }
    }
  }
}
```

--------------------------------

### Install and Verify CLIs (Bash)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

This snippet shows the commands to install and verify the versions of required command-line interfaces (CLIs): Bun, GitHub CLI, and Railway. These tools are necessary for running and deploying the agent.

```bash
# Required CLIs
bun --version    # Bun runtime
gh --version     # GitHub CLI (for publishing)
railway --help   # Railway CLI (for deployment)
```

--------------------------------

### Implement a Free 'Try Before Buy' Endpoint (TypeScript)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/b2a-agents/skills/SKILL.md

Provides an example of creating a mandatory free endpoint for agent services, allowing potential consumers to test functionality and assess data availability before committing to paid tiers.

```typescript
// Every agent needs a free "try before buy" endpoint
addEntrypoint({
  key: 'overview',
  description: 'Free overview - see what data is available',
  price: { amount: 0 },
  handler: async () => {
    // Placeholder for fetching sample data
    const fetchSample = async () => ({ sample: 'data' }); 
    return {
      output: {
        available: ['lookup', 'search', 'aggregate', 'analyze'],
        dataSource: 'Multi-exchange aggregated',
        updateFrequency: '30 seconds',
        sampleData: await fetchSample()
      }
    };
  }
});
```

--------------------------------

### Create Lucid Agents with JavaScript

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agent-creator/skills/SKILL.md

Demonstrates how to create different types of agents using the create_lucid_agent function. Includes examples for a simple echo agent, a paid agent utilizing fetch for external API calls, and an agent configured with identity settings.

```javascript
// Create a simple echo agent
await create_lucid_agent({
  slug: "echo-agent",
  name: "Echo Agent",
  description: "Echoes input back",
  entrypoints: [
    {
      key: "echo",
      description: "Echo the input",
      handlerType: "js",
      handlerConfig: {
        code: "return { echoed: input };"
      }
    }
  ]
});

// Create a paid agent with fetch
await create_lucid_agent({
  slug: "weather-agent",
  name: "Weather Agent",
  description: "Fetches weather data",
  entrypoints: [
    {
      key: "get-weather",
      description: "Get weather by city",
      handlerType: "js",
      handlerConfig: {
        code: `
          const res = await fetch(`https://api.weather.com/data?city=${encodeURIComponent(input.city)}`);
          const data = await res.json();
          return data;
        `,
        network: {
          allowedHosts: ["api.weather.com"]
        }
      },
      price: "1000" // 0.001 USDC
    }
  ]
});

// Create agent with identity config
await create_lucid_agent({
  slug: "identity-agent",
  name: "Identity Agent",
  description: "Agent with ERC-8004 identity",
  entrypoints: [
    {
      key: "process",
      handlerType: "js",
      handlerConfig: {
        code: "return { result: input };"
      }
    }
  ],
  identityConfig: {
    chainId: 1, // Ethereum mainnet
    autoRegister: true,
    trustModels: ["feedback", "inference-validation"]
  }
});
```

--------------------------------

### TanStack Adapter for Agent (TypeScript)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Demonstrates the integration of an agent with TanStack using the '@lucid-agents/tanstack' adapter. This example shows how to create a TanStack runtime for the agent and add entrypoints.

```typescript
import { createAgent } from '@lucid-agents/core';
import { http } from '@lucid-agents/http';
import { createTanStackRuntime } from '@lucid-agents/tanstack';

const agent = await createAgent({
  name: 'my-agent',
  version: '1.0.0',
})
  .use(http())
  .build();

const { runtime: tanStackRuntime, handlers } = await createTanStackRuntime(agent);

// Use runtime.addEntrypoint() instead of addEntrypoint()
tanStackRuntime.addEntrypoint({ ... });

// Export for TanStack routes
export { runtime: tanStackRuntime, handlers };
```

--------------------------------

### Express Adapter for Agent (TypeScript)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Illustrates how to integrate a created agent with the Express.js framework using the '@lucid-agents/express' adapter. This example sets up an agent and prepares it to be served via an Express application.

```typescript
import { createAgent } from '@lucid-agents/core';
import { http } from '@lucid-agents/http';
import { createAgentApp } from '@lucid-agents/express';

const agent = await createAgent({
  name: 'my-agent',
  version: '1.0.0',
})
  .use(http())
  .build();

const { app, addEntrypoint } = await createAgentApp(agent);

// Express apps need to listen on a port
const server = app.listen(process.env.PORT ?? 3000);
```

--------------------------------

### Moltbook Credentials Setup (JSON)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/moltbook-promotion/skills/SKILL.md

This JSON snippet shows the structure for saving Moltbook API credentials, including the API key and agent name. This file is typically located at `~/.config/moltbook/credentials.json`.

```json
{
  "api_key": "moltbook_sk_...",
  "agent_name": "your_agent_name"
}
```

--------------------------------

### Monorepo Setup for Crypto Trading Agents (Bash)

Source: https://context7.com/daydreamsai/skills-market/llms.txt

This snippet demonstrates how to set up a monorepo for multiple AI agents using npm workspaces. It includes creating the directory structure, initializing a root package.json with workspace configuration, and setting up build, test, and development scripts.

```bash
mkdir -p crypto-trading-agents/packages
cd crypto-trading-agents

cat > package.json << 'EOF'
{
  "name": "crypto-trading-agents",
  "version": "1.0.0",
  "private": true,
  "workspaces": ["packages/*"],
  "scripts": {
    "build": "bun run --filter '*' build",
    "test": "bun run --filter '*' test",
    "dev:all": "bun run --filter '*' dev"
  }
}
EOF
```

--------------------------------

### Workspace-Level Commands (Bun)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Provides common commands for managing the monorepo at the workspace level using Bun. These commands cover dependency installation, building all packages, creating changesets, versioning, and publishing.

```bash
# Install dependencies
bun install

# Build all packages
bun run build:packages

# Create changeset
bun run changeset

# Version packages
bun run release:version

# Publish packages
bun run release:publish
```

--------------------------------

### Deploy Lucid Agents to Railway

Source: https://context7.com/daydreamsai/skills-market/llms.txt

Automates the deployment of Lucid Agents to Railway, including GitHub repository creation, Railway service setup, environment variable configuration, and domain setup. Requires GitHub CLI (`gh`) and Railway CLI (`railway`) to be installed and authenticated.

```bash
# Prerequisites
brew install gh  # GitHub CLI
npm install -g @railway/cli
gh auth login
railway login

# Required environment variables
export RAILWAY_TOKEN="<your-railway-token>"
export PAYMENTS_RECEIVABLE_ADDRESS="<your-wallet-address>"

# Step 1: Create GitHub repository
cd my-agent
git init
git add .
git commit -m "Initial commit: my-agent"
gh repo create username/my-agent --public --source=. --push

# Step 2: Link to Railway
railway init  # Create new project
# or: railway link --project <project-id>

# Step 3: Create service with env vars
railway add -s my-agent \
  -v "PAYMENTS_RECEIVABLE_ADDRESS=0x..." \
  -v "FACILITATOR_URL=https://facilitator.daydreams.systems" \
  -v "NETWORK=base"

# Or update existing service
railway variables set \
  PAYMENTS_RECEIVABLE_ADDRESS=0x... \
  FACILITATOR_URL=https://facilitator.daydreams.systems \
  NETWORK=base \
  --service my-agent

# Step 4: Deploy
railway up --detach --service my-agent

# Step 5: Configure domain
railway domain --service my-agent
# Output: https://my-agent-production.up.railway.app

# Step 6: Verify deployment
sleep 90  # Wait for build
curl -s https://my-agent-production.up.railway.app/health | jq
curl -s -X POST https://my-agent-production.up.railway.app/entrypoints/overview/invoke \
  -H "Content-Type: application/json" -d '{}' | jq

# Troubleshooting
railway logs --build --service my-agent  # Check build logs
railway service status  # List services
```

--------------------------------

### Initialize Git Repository and Commit

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/paid-agent/skills/SKILL.md

This snippet demonstrates the bash commands to initialize a Git repository, stage all files, and then use the 'commit' skill to create a commit with proper formatting and reasoning.

```Bash
cd {project-directory}
git init
git add -A
Skill("commit")
```

--------------------------------

### Dockerfile for Cult Film Curtis Agent

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Defines the Docker image for the Cult Film Curtis agent. It uses Oven's Bun runtime, copies project files, installs dependencies, and sets the default command to start the agent.

```dockerfile
FROM oven/bun:1

WORKDIR /app

COPY package.json bun.lockb* ./
RUN bun install --frozen-lockfile

COPY . .

ENV PORT=3000
EXPOSE 3000

CMD ["bun", "run", "start"]
```

--------------------------------

### Testing Cult Film Curtis Agent Locally (Bash)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Provides bash commands to test the Cult Film Curtis agent. Includes steps for installing dependencies, starting the local server, and testing free and paid endpoints using curl.

```bash
# 1. Install dependencies
bun install

# 2. Start locally
bun run dev

# 3. Test free endpoints
curl http://localhost:3000/health
curl http://localhost:3000/catalog

# 4. Test paid endpoint (will return 402 without payment)
curl -X POST http://localhost:3000/entrypoints/recommend/invoke \
  -H "Content-Type: application/json" \
  -d '{"mood": "weird"}'
```

--------------------------------

### B2A Agent Setup and Entrypoints (TypeScript)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/b2a-agents/skills/SKILL.md

Sets up a B2A agent using @lucid-agents, integrating HTTP and payments. It defines multiple entrypoints: a free 'overview' endpoint, a paid 'lookup' endpoint for specific items, and a paid 'aggregate' endpoint for multi-source data. Includes a caching mechanism for rate-limit protection.

```typescript
import { createAgent } from '@lucid-agents/core';
import { http } from '@lucid-agents/http';
import { createAgentApp } from '@lucid-agents/hono';
import { payments, paymentsFromEnv } from '@lucid-agents/payments';
import { z } from 'zod';

const agent = await createAgent({
  name: 'data-feed-agent',
  version: '1.0.0',
  description: 'Aggregated data feed for AI agents',
})
  .use(http())
  .use(payments({ config: paymentsFromEnv() }))
  .build();

const { app, addEntrypoint } = await createAgentApp(agent);

// Cache for rate-limit protection
const cache = new Map<string, { data: any; timestamp: number }>();
const CACHE_TTL = 30_000; // 30 seconds

async function fetchWithCache(key: string, fetcher: () => Promise<any>) {
  const cached = cache.get(key);
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return { ...cached.data, fromCache: true };
  }
  const data = await fetcher();
  cache.set(key, { data, timestamp: Date.now() });
  return { ...data, fromCache: false };
}

// FREE: Discovery endpoint
addEntrypoint({
  key: 'overview',
  description: 'Free overview of available data',
  input: z.object({}),
  price: { amount: 0 },
  handler: async () => ({
    output: {
      endpoints: ['lookup', 'list', 'aggregate'],
      sources: ['source1', 'source2'],
      updateFrequency: '30s',
      fetchedAt: new Date().toISOString()
    }
  })
});

// PAID: Lookup
addEntrypoint({
  key: 'lookup',
  description: 'Look up specific item',
  input: z.object({ id: z.string() }),
  price: { amount: 1000 }, // $0.001
  handler: async (ctx) => {
    const result = await fetchWithCache(`lookup:${ctx.input.id}`, async () => {
      // Fetch from real API
      return fetch(`https://api.example.com/${ctx.input.id}`).then(r => r.json());
    });
    return { output: { ...result, fetchedAt: new Date().toISOString() } };
  }
});

// PAID: Aggregated multi-source
addEntrypoint({
  key: 'aggregate',
  description: 'Aggregated data from multiple sources',
  input: z.object({
    ids: z.array(z.string()).max(10),
    sources: z.array(z.string()).optional()
  }),
  price: { amount: 3000 }, // $0.003
  handler: async (ctx) => {
    const results = await Promise.all(
      ctx.input.ids.map(id => fetchWithCache(`agg:${id}`, () => 
        aggregateFromSources(id, ctx.input.sources)
      ))
    );
    return { 
      output: { 
        items: results,
        count: results.length,
        fetchedAt: new Date().toISOString()
      }
    };
  }
});

export default { port: Number(process.env.PORT ?? 3000), fetch: app.fetch };

```

--------------------------------

### Development Commands for AI Agent Project

Source: https://context7.com/daydreamsai/skills-market/llms.txt

These commands are used for managing the development lifecycle of an AI agent project. They include installing dependencies, starting a development server, building for production, running tests, and performing type checking. Navigate to the agent's directory before executing these commands.

```bash
cd my-agent
bun install
bun run dev
bun run build
bun test
bunx tsc --noEmit
```

--------------------------------

### JavaScript Entrypoint Handler Example

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agent-creator/skills/SKILL.md

This snippet demonstrates a basic JavaScript handler for an agent entrypoint. It shows how to access input, perform a simple operation, and return a result. The handler is executed within a JavaScript environment, with access to global variables like `input` and `output`.

```javascript
/**
 * Example JavaScript handler for an agent entrypoint.
 * Receives input via the global `input` variable.
 * Can optionally set global `output`.
 */

// Example: Accessing input
const userMessage = input.text;

// Example: Performing an operation
const response = `You said: ${userMessage}. This is a test response.`;

// Example: Setting output
output.reply = response;

// No explicit return needed; output is captured.
```

--------------------------------

### Monorepo Structure Initialization

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/autonomous-lucid/skills/SKILL.md

This snippet outlines the initial steps for creating the monorepo structure. It includes creating the main directory, the 'packages' subdirectory, and essential configuration files like package.json with workspaces, tsconfig.base.json, .gitignore, and a README.md template.

```bash
mkdir -p {monorepo-name}/packages
cd {monorepo-name}

# Create root package.json with workspaces
# Create tsconfig.base.json
# Create .gitignore
# Create README.md template
```

--------------------------------

### Install Railway CLI

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/railway-deploy/skills/SKILL.md

Installs the Railway command-line interface, necessary for interacting with Railway projects and services. Authentication can be done via login or by setting the RAILWAY_TOKEN environment variable.

```bash
npm install -g @railway/cli
railway login
# or set RAILWAY_TOKEN env var
```

--------------------------------

### Initialize Git and Commit Monorepo

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/autonomous-lucid/skills/SKILL.md

Initializes a Git repository in the monorepo directory, stages all changes, and commits them using the 'Skill("commit")' function. This prepares the monorepo for version control and publishing.

```bash
cd {monorepo-name}
git init
git add -A
Skill("commit")  # Uses /commit skill
```

--------------------------------

### Research Agent Example

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/autonomous-lucid/skills/SKILL.md

An example of using a 'research-agent' skill to gather comprehensive information about a specific domain, such as cryptocurrency trading. This is typically the first step in generating agent ideas.

```python
Skill("research-agent", args: "Research cryptocurrency trading comprehensively...")
```

--------------------------------

### Create a New Template (Steps)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Guidelines for creating a new agent template within the Lucid Agents CLI. This involves setting up a new directory, defining necessary files like agent code, package configurations, and documentation.

```text
1. Create directory: `packages/cli/templates/my-template/`
2. Add required files: `src/agent.ts`, `src/index.ts`, `package.json`, `tsconfig.json`
3. Create `template.json` with wizard configuration
4. Create `template.schema.json` documenting all arguments
5. Create `AGENTS.md` with comprehensive examples
6. Test: `bunx ./packages/cli/dist/index.js test-agent --template=my-template`
```

--------------------------------

### Gather Requirements using AskUserQuestion

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/autonomous-lucid/skills/SKILL.md

This snippet demonstrates how to use the AskUserQuestion tool to gather essential information from the user, including the domain, monorepo name, and deployment preference. These inputs are crucial for initiating the agent generation process.

```bash
AskUserQuestion with:
- "What domain should we build agents for?"
- "What should we name the monorepo?" (suggest based on domain)
- "Deploy all agents to Railway immediately?" (yes/no)
```

--------------------------------

### Create and Push GitHub Repository

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/paid-agent/skills/SKILL.md

Uses the GitHub CLI ('gh') to create a new public repository, set the source to the current directory, establish an origin remote, and push the initial commit.

```Bash
gh repo create {repo-name} --public --source=. --remote=origin --push --description "{Agent description}"
```

--------------------------------

### Get Specific Service API

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/xgate-server/skills/xgate-server.md

Retrieves details for a specific service using its ID.

```APIDOC
## GET /services/{SERVICE_ID}

### Description
Retrieves detailed information about a specific service identified by its SERVICE_ID.

### Method
GET

### Endpoint
https://xgate.run/services/{SERVICE_ID}

### Parameters
#### Path Parameters
- **SERVICE_ID** (string) - Required - The unique identifier of the service

### Request Example
```json
{
  "example": "curl -s https://xgate.run/services/SERVICE_ID | jq"
}
```

### Response
#### Success Response (200)
- **service_details** (object) - Detailed information about the requested service

#### Response Example
```json
{
  "example": "[Service details object]"
}
```
```

--------------------------------

### GET /health

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Free endpoint to check the health status of the agent.

```APIDOC
## GET /health

### Description
Provides a free health check for the Cult Film Curtis agent to ensure it is running and responsive.

### Method
GET

### Endpoint
/health

### Response
#### Success Response (200)
- **status** (string) - Indicates the health status, typically "ok".

#### Response Example
```json
{
  "status": "ok"
}
```
```

--------------------------------

### Monorepo Structure Overview

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Illustrates the directory structure of the monorepo, detailing the purpose of each package within the 'packages' directory. This structure helps organize different functionalities like core runtime, HTTP extensions, wallet SDK, and various adapters.

```bash
/
├── packages/
│   ├── core/               # Protocol-agnostic runtime
│   ├── http/               # HTTP extension
│   ├── wallet/             # Wallet SDK
│   ├── payments/           # x402 payment utilities
│   ├── analytics/          # Payment analytics
│   ├── identity/           # ERC-8004 identity
│   ├── a2a/                # A2A Protocol client
│   ├── ap2/                # AP2 extension
│   ├── hono/               # Hono adapter
│   ├── express/            # Express adapter
│   ├── tanstack/           # TanStack adapter
│   └── cli/                # CLI scaffolding tool
├── scripts/
└── package.json            # Workspace config
```

--------------------------------

### GET /catalog

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Free endpoint to retrieve a list of all available cult films in the catalog.

```APIDOC
## GET /catalog

### Description
Retrieves a list of all cult films available in the agent's catalog. This is a free endpoint.

### Method
GET

### Endpoint
/catalog

### Response
#### Success Response (200)
- **catalog** (array of objects) - A list of cult films.
  - Each object represents a film and contains:
    - **id** (string) - Unique identifier for the film.
    - **title** (string) - The title of the film.
    - **year** (integer) - The release year of the film.
    - **director** (string) - The director of the film.
    - **synopsis** (string) - A brief synopsis of the film.
    - **genre** (array of strings) - The genres associated with the film.
    - **why_cult** (string) - Explanation of why the film is considered a cult classic.
    - **discourse_score** (number) - A score representing the film's cult status or discourse.

#### Response Example
```json
{
  "catalog": [
    {
      "id": "the-room",
      "title": "The Room",
      "year": 2003,
      "director": "Tommy Wiseau",
      "synopsis": "A successful banker's life begins to unravel when his fiancée starts an affair with his best friend.",
      "genre": ["drama", "comedy", "cult"],
      "why_cult": "Widely considered one of the worst films ever made, yet it has gained a massive cult following due to its unintentional humor and bizarre dialogue.",
      "discourse_score": 3
    },
    {
      "id": "videodrome",
      "title": "Videodrome",
      "year": 1983,
      "director": "David Cronenberg",
      "synopsis": "A}.$partial_response
```
```

--------------------------------

### POST /details

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Get detailed information about a specific cult film using its ID.

```APIDOC
## POST /details

### Description
Get detailed information about a specific cult film using its ID. The film ID can be found in the `/catalog` endpoint response.

### Method
POST

### Endpoint
/details

### Parameters
#### Request Body
- **filmId** (string) - Required - The unique identifier of the film (e.g., 'the-room', 'eraserhead').

### Request Example
```json
{
  "filmId": "eraserhead"
}
```

### Response
#### Success Response (200)
- **output** (object) - Contains the detailed film information.
  - **film** (object) - Details of the requested cult film.
    - **id** (string) - Unique identifier for the film.
    - **title** (string) - The title of the film.
    - **year** (integer) - The release year of the film.
    - **director** (string) - The director of the film.
    - **synopsis** (string) - A brief synopsis of the film.
    - **genre** (array of strings) - The genres associated with the film.
    - **why_cult** (string) - Explanation of why the film is considered a cult classic.
    - **discourse_score** (number) - A score representing the film's cult status or discourse.

#### Error Response (404)
- **output** (object) - Contains an error message and available film IDs.
  - **error** (string) - "Film not found"
  - **available_ids** (array of strings) - A list of valid film IDs.

#### Response Example (Success)
```json
{
  "output": {
    "film": {
      "id": "eraserhead",
      "title": "Eraserhead",
      "year": 1977,
      "director": "David Lynch",
      "synopsis": "A man in a strange industrial landscape must care for his child in an apartment with constantly running radiator pipes.",
      "genre": ["drama", "horror", "cult"],
      "why_cult": "A surreal and disturbing masterpiece that has captivated and bewildered audiences for decades, becoming a benchmark for arthouse horror.",
      "discourse_score": 2
    }
  }
}
```

#### Response Example (Error)
```json
{
  "output": {
    "error": "Film not found",
    "available_ids": ["the-room", "videodrome", ...]
  }
}
```
```

--------------------------------

### Create and Push GitHub Repository

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/autonomous-lucid/skills/SKILL.md

Creates a new public GitHub repository for the monorepo, sets the origin remote, and pushes the initialized Git repository. This makes the monorepo accessible and shareable on GitHub.

```bash
gh repo create {monorepo-name} --public --source=. --remote=origin --push --description "{DOMAIN} AI Agent Suite - 10 production Lucid Agents"
```

--------------------------------

### Get xgate-server Usage Statistics

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/xgate-server/skills/xgate-server.md

Retrieves usage statistics for the xgate-server API. This endpoint provides insights into API utilization.

```bash
curl -s https://xgate.run/services/usage | jq
```

--------------------------------

### Core Agent Creation (TypeScript)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Demonstrates how to create a core agent using the '@lucid-agents/core' library. It shows how to configure the agent with basic information and add an entrypoint for a 'greet' function.

```typescript
import { createAgent } from '@lucid-agents/core';
import { http } from '@lucid-agents/http';
import { z } from 'zod';

const agent = await createAgent({
  name: 'my-agent',
  version: '1.0.0',
  description: 'My first agent',
})
  .use(http())
  .build();

agent.entrypoints.add({
  key: 'greet',
  input: z.object({ name: z.string() }),
  async handler({ input }) {
    return { output: { message: `Hello, ${input.name}` } };
  },
});
```

--------------------------------

### Optimize Programmatic Access with Typed Inputs (TypeScript)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/b2a-agents/skills/SKILL.md

Demonstrates how to design agent entrypoints with clear, typed inputs using Zod for robust validation. Contrasts good practices (typed, predictable) with bad practices (vague, human-oriented).

```typescript
import { z } from 'zod';

// ✅ Good: Clean, typed, predictable
addEntrypoint({
  key: 'lookup',
  input: z.object({
    symbol: z.string(),
    exchanges: z.array(z.string()).optional()
  }),
  handler: async (ctx) => {
    // ... handler logic ...
    return { output: { symbol: ctx.input.symbol, prices: [], timestamp: new Date().toISOString() } };
  }
});

// ❌ Bad: Human-oriented, vague
addEntrypoint({
  key: 'search',
  input: z.object({ query: z.string() }), // Too vague
  handler: async (ctx) => {
    // ... handler logic ...
    return { output: { message: "Here's what I found..." } }; // Prose, not data
  }
});
```

--------------------------------

### POST /recommend

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Get a cult film recommendation. You can optionally provide a mood or preference to filter the recommendations.

```APIDOC
## POST /recommend

### Description
Get a cult film recommendation from Curtis. You can optionally provide a mood or preference (e.g., 'weird', 'scary', 'funny') to filter the recommendations.

### Method
POST

### Endpoint
/recommend

### Parameters
#### Query Parameters
- **mood** (string) - Optional - The desired mood or preference for the film recommendation.

### Request Body
```json
{
  "mood": "string" 
}
```

### Request Example
```json
{
  "mood": "weird"
}
```

### Response
#### Success Response (200)
- **output** (object) - Contains the recommended film details.
  - **film** (object) - Details of the recommended cult film.
    - **id** (string) - Unique identifier for the film.
    - **title** (string) - The title of the film.
    - **year** (integer) - The release year of the film.
    - **director** (string) - The director of the film.
    - **synopsis** (string) - A brief synopsis of the film.
    - **genre** (array of strings) - The genres associated with the film.
    - **why_cult** (string) - Explanation of why the film is considered a cult classic.
    - **discourse_score** (number) - A score representing the film's cult status or discourse.

#### Response Example
```json
{
  "output": {
    "film": {
      "id": "the-room",
      "title": "The Room",
      "year": 2003,
      "director": "Tommy Wiseau",
      "synopsis": "A successful banker's life begins to unravel when his fiancée starts an affair with his best friend.",
      "genre": ["drama", "comedy", "cult"],
      "why_cult": "Widely considered one of the worst films ever made, yet it has gained a massive cult following due to its unintentional humor and bizarre dialogue.",
      "discourse_score": 3
    }
  }
}
```
```

--------------------------------

### Get xgate-server OpenAPI Specification

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/xgate-server/skills/xgate-server.md

Fetches the OpenAPI specification for the xgate-server API. This is useful for understanding the API structure and for generating client libraries.

```bash
curl -s https://xgate.run/doc | jq
```

--------------------------------

### Link Local Packages for Testing (Bash)

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-agents-sdk/skills/SKILL.md

Steps to use Bun's linking feature to test local changes in packages. This involves globally registering local packages and then updating a test project's `package.json` to link to them.

```bash
cd packages/types
bun link

cd ../wallet
bun link

# Update test project's package.json:
# {
#   "dependencies": {
#     "@lucid-agents/wallet": "link:@lucid-agents/wallet"
#   }
# }

cd my-test-agent
bun install

# Make changes and rebuild:
cd lucid-agents/packages/wallet
# Make changes
bun run build
# Changes reflected immediately
```

--------------------------------

### Get Recommendation API

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/cult-film-curtis/skills/SKILL.md

Provides a weighted random recommendation for a cult film. The recommendation is weighted by the film's discourse score.

```APIDOC
## POST /recommend

### Description
Provides a weighted random recommendation for a cult film. The recommendation is weighted by the film's discourse score.

### Method
POST

### Endpoint
/recommend

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the recommended film.
- **title** (string) - The title of the recommended film.
- **year** (integer) - The release year of the recommended film.
- **director** (string) - The director of the recommended film.
- **genre** (array) - An array of strings representing the film's genres.
- **runtime_min** (integer) - The runtime of the film in minutes.
- **rating** (float) - The rating of the film.
- **synopsis** (string) - A brief synopsis of the film.
- **why_cult** (string) - Explanation of why the film is considered a cult classic.
- **viewing_tips** (string) - Tips for viewing the film.
- **availability** (array) - An array of strings listing platforms where the film is available.
- **metadata** (object) - Additional metadata about the recommendation:
  - **source** (string) - The source of the recommendation (e.g., "cult-film-curtis").
  - **timestamp** (string) - The ISO 8601 timestamp of when the recommendation was generated.
  - **discourse_score** (integer) - The discourse score used for weighting the recommendation.
  - **curator** (string) - The name of the curator (e.g., "Curtis").

#### Response Example
```json
{
  "id": "repo-man",
  "title": "Repo Man",
  "year": 1984,
  "director": "Alex Cox",
  "genre": [
    "sci-fi",
    "comedy",
    "punk"
  ],
  "runtime_min": 92,
  "rating": 6.9,
  "synopsis": "A punk rocker becomes a repo agent and chases a Chevy Malibu with something mysterious in its trunk.",
  "why_cult": "Captures Reagan-era punk perfectly. The generic 'FOOD' products. Harry Dean Stanton's philosophy.",
  "viewing_tips": "Pay attention to every background detail. The Iggy Pop soundtrack is essential.",
  "availability": [
    "Criterion Channel",
    "Tubi"
  ],
  "metadata": {
    "source": "cult-film-curtis",
    "timestamp": "2023-10-27T10:05:00.000Z",
    "discourse_score": 7,
    "curator": "Curtis"
  }
}
```
```

--------------------------------

### Agent Invocation with Payment Handling

Source: https://github.com/daydreamsai/skills-market/blob/main/plugins/lucid-client-api/skills/SKILL.md

Invoke an agent entrypoint, handling potential payment requirements using the x402 protocol.

```APIDOC
## POST /agents/{agentId}/entrypoints/{key}/invoke

### Description
Invokes a specific entrypoint of an agent. Handles payment requirements using the x402 protocol if necessary.

### Method
POST

### Endpoint
/agents/{agentId}/entrypoints/{key}/invoke

### Parameters
#### Path Parameters
- **agentId** (string) - Required - The ID of the agent to invoke.
- **key** (string) - Required - The key of the entrypoint to invoke.

#### Query Parameters
None

#### Request Body
- **input** (object) - Required - The input payload for the agent entrypoint.

### Request Example
```json
{
  "input": {
    "query": "What is the weather today?"
  }
}
```

### Response
#### Success Response (200)
- **output** (any) - The result of the agent invocation.

#### Error Response (402 Payment Required)
- **Headers**
  - **X-Payment-Price** (string) - The price for the invocation.
  - **X-Payment-Network** (string) - The payment network.
  - **X-Payment-PayTo** (string) - The payment address.

#### Response Example (Success)
```json
{
  "output": "The weather today is sunny with a high of 75 degrees Fahrenheit."
}
```

#### Response Example (Payment Required)
(Headers will contain payment details, response body might be empty or contain minimal info)

```