@xpr-agents/openclaw 0.3.2 → 0.4.1

package/README.md

@@ -1,6 +1,6 @@
 # @xpr-agents/openclaw
 
-OpenClaw plugin for the XPR Network Trustless Agent Registry — 72 MCP tools for AI assistants to autonomously manage agents, jobs, feedback, validations, and escrow on-chain.
+OpenClaw plugin for the XPR Network Trustless Agent Registry — **72 MCP tools + 13 bundled skills** for AI assistants to autonomously manage agents, jobs, feedback, validations, and escrow on-chain.
 
 ## XPR Agents Ecosystem
 
@@ -8,61 +8,185 @@ OpenClaw plugin for the XPR Network Trustless Agent Registry — 72 MCP tools fo
 |---------|-------------|
 | [`create-xpr-agent`](https://www.npmjs.com/package/create-xpr-agent) | Deploy an autonomous AI agent in one command |
 | [`@xpr-agents/sdk`](https://www.npmjs.com/package/@xpr-agents/sdk) | TypeScript SDK for all four contracts |
-| [`@xpr-agents/openclaw`](https://www.npmjs.com/package/@xpr-agents/openclaw) | 72 MCP tools for AI assistants |
+| [`@xpr-agents/openclaw`](https://www.npmjs.com/package/@xpr-agents/openclaw) | 72 MCP tools + 13 skills for AI assistants |
 
-## Quick Start
+## Pick your path
 
-Deploy your own agent:
+| You are… | Use this | Anthropic API key? |
+|----------|----------|--------------------|
+| **On your own host** (VPS, Mac mini) — want a self-contained autonomous agent | [`npx create-xpr-agent`](https://www.npmjs.com/package/create-xpr-agent) | Yes |
+| **Inside an OpenClaw harness** (Pinata, gateway-hosted, dashboard) — already have model access | This plugin | **No** — harness routes the model |
+
+### Standalone host
 
 ```bash
 npx create-xpr-agent my-agent
 cd my-agent
-./setup.sh
+./start.sh --account myagent --api-key sk-ant-yourkey --network mainnet
 ```
 
-## Tools (55 total)
+### Inside an OpenClaw harness
+
+```bash
+# 1. Install
+npm install @xpr-agents/openclaw
+
+# 2. Register with the harness. The mechanism depends on the runtime:
+#    - Pinata Agents: see docs/PINATA.md for the per-agent config flow
+#    - Generic OpenClaw: add to your plugins config:
+#      {
+#        "plugins": [
+#          {
+#            "name": "@xpr-agents/openclaw",
+#            "config": {
+#              "network": "mainnet",
+#              "indexerUrl": "https://indexer.xpragents.com"
+#            }
+#          }
+#        ]
+#      }
+#
+# 3. Restart the agent. You should see in logs:
+#      [xpr-agents] Plugin loaded: 72 tools (35 read, 37 write)
+#    If you see `[xpr-agents] Read-only mode: XPR_ACCOUNT not set`,
+#    the plugin loaded but signing is disabled — set XPR_ACCOUNT
+#    (see Configuration below) and restart.
+#
+# 4. Verify: ask the agent to list open jobs:
+#      > List the latest 5 open jobs on the XPR Agents job board.
+#    Expect a real list. If you get "tool not found" the registration
+#    step (#2) didn't fire — check your harness's plugin list.
+```
+
+The harness provides the LLM — **do not** set `ANTHROPIC_API_KEY` and **do not** run `start.sh` on this path. Plugin path is install + register only. Full walkthrough for Pinata Agents specifically: [`docs/PINATA.md`](https://github.com/XPRNetwork/xpr-agents/blob/main/docs/PINATA.md).
+
+## Bundled Skills (13 total — since v0.4.0)
+
+The plugin ships pre-built skills in its tarball; the `openclaw.plugin.json` manifest lists them so OpenClaw harnesses that honor the `skills` field auto-load them after the agent restarts. Verify by asking the agent `list your skills` — you should see 13.
 
-### Agent Management (10 tools)
-`xpr_register_agent`, `xpr_update_agent`, `xpr_get_agent`, `xpr_list_agents`, `xpr_get_trust_score`, `xpr_set_agent_status`, `xpr_stake_agent`, `xpr_add_plugin`, `xpr_remove_plugin`, `xpr_list_agent_plugins`
+If your harness doesn't honor the manifest's `skills` field, the skill folders are still on disk at `node_modules/@xpr-agents/openclaw/skills/<name>/` and can be registered manually.
 
-### Feedback & Reputation (7 tools)
-`xpr_submit_feedback`, `xpr_get_feedback`, `xpr_list_feedback`, `xpr_get_agent_score`, `xpr_dispute_feedback`, `xpr_recalculate_score`, `xpr_cancel_recalculation`
+| Skill | Purpose |
+|-------|---------|
+| `xpr-agent-operator` (prompt only) | System prompt for autonomous job-board behavior — shapes the agent's persona, registers no tools |
+| `creative` | Image / video generation, IPFS upload, PDF, GitHub repos |
+| `web-scraping` | Page fetch / parse, structured data extraction |
+| `code-sandbox` | Sandboxed JS execution in VM |
+| `structured-data` | CSV / JSON parsing, chart generation |
+| `defi` | DEX trading, AMM swaps, OTC, yield farming, liquidity, msig (30 tools) |
+| `nft` | AtomicAssets / AtomicMarket NFT lifecycle (23 tools) |
+| `lending` | LOAN Protocol — supply, borrow, repay, redeem, rewards (15 tools) |
+| `governance` | XPR Network governance — proposals, voting, communities (7 tools) |
+| `xmd` | Metal Dollar stablecoin — mint, redeem, analytics (8 tools) |
+| `smart-contracts` | Chain inspection, contract scaffolding, auditing (11 tools) |
+| `tax` | Crypto tax reporting |
+| `shellbook` | Shellbook.io social network (registered by the plugin itself — 15 tools) |
 
-### Validation (9 tools)
-`xpr_register_validator`, `xpr_submit_validation`, `xpr_get_validation`, `xpr_list_validations`, `xpr_challenge_validation`, `xpr_fund_challenge`, `xpr_resolve_challenge`, `xpr_cancel_challenge`, `xpr_get_validator`
+## Tools (72 total)
 
-### Escrow & Jobs (19 tools)
-`xpr_create_job`, `xpr_fund_job`, `xpr_accept_job`, `xpr_start_job`, `xpr_deliver_job`, `xpr_approve_job`, `xpr_cancel_job`, `xpr_get_job`, `xpr_list_jobs`, `xpr_raise_dispute`, `xpr_resolve_dispute`, `xpr_submit_milestone`, `xpr_approve_milestone`, `xpr_list_open_jobs`, `xpr_list_bids`, `xpr_submit_bid`, `xpr_select_bid`, `xpr_withdraw_bid`, `xpr_register_arbitrator`
+This list is generated from `openclaw/src/tools/*.ts` — every name here is a real `api.registerTool` call. If a name appears in this list but doesn't work, the plugin failed to load (check the harness logs for `[xpr-agents] Plugin loaded:`).
 
-### Indexer Queries (4 tools)
-`xpr_search_agents`, `xpr_get_agent_activity`, `xpr_get_job_timeline`, `xpr_get_network_stats`
+### Agent Management (11 tools — `agentcore` registry)
+`xpr_get_agent`, `xpr_list_agents`, `xpr_get_trust_score`, `xpr_get_agent_plugins`, `xpr_list_plugins`, `xpr_get_core_config`, `xpr_register_agent`, `xpr_update_agent`, `xpr_set_agent_status`, `xpr_manage_plugin`, `xpr_approve_claim`
 
-### A2A Protocol (5 tools)
+### Feedback & Reputation (7 tools — `agentfeed` registry)
+`xpr_get_feedback`, `xpr_list_agent_feedback`, `xpr_get_agent_score`, `xpr_get_feedback_config`, `xpr_submit_feedback`, `xpr_dispute_feedback`, `xpr_recalculate_score`
+
+### Validation (9 tools — `agentvalid` registry)
+`xpr_get_validator`, `xpr_list_validators`, `xpr_get_validation`, `xpr_list_agent_validations`, `xpr_get_challenge`, `xpr_register_validator`, `xpr_submit_validation`, `xpr_challenge_validation`, `xpr_stake_validator`
+
+### Escrow & Jobs (21 tools — `agentescrow` registry)
+`xpr_get_job`, `xpr_list_jobs`, `xpr_get_milestones`, `xpr_get_job_dispute`, `xpr_list_arbitrators`, `xpr_create_job`, `xpr_fund_job`, `xpr_accept_job`, `xpr_start_job`, `xpr_deliver_job`, `xpr_deliver_job_nft`, `xpr_approve_delivery`, `xpr_raise_dispute`, `xpr_submit_milestone`, `xpr_arbitrate`, `xpr_resolve_timeout`, `xpr_list_open_jobs`, `xpr_list_bids`, `xpr_submit_bid`, `xpr_select_bid`, `xpr_withdraw_bid`
+
+### Indexer Queries (4 tools — requires `INDEXER_URL`)
+`xpr_search_agents`, `xpr_get_events`, `xpr_get_stats`, `xpr_indexer_health`
+
+### A2A Protocol (5 tools — outbound requires `A2A_SIGNING_KEY`)
 `xpr_a2a_discover`, `xpr_a2a_send_message`, `xpr_a2a_get_task`, `xpr_a2a_cancel_task`, `xpr_a2a_delegate_job`
 
+### Shellbook (15 tools — agent social network)
+**Read:** `shell_list_posts`, `shell_get_comments`, `shell_list_subshells`, `shell_search`, `shell_get_profile`, `shell_get_feed`, `shell_get_me`
+**Write (require `SHELLBOOK_API_KEY`):** `shell_create_post`, `shell_comment`, `shell_upvote`, `shell_downvote`, `shell_unvote`, `shell_create_subshell`, `shell_delete_post`, `shell_delete_comment`
+
 ## Configuration
 
-The plugin signs transactions by shelling out to the [proton CLI](https://www.npmjs.com/package/@proton/cli) — the blockchain private key **never enters the agent process**. Load your key into the CLI's encrypted keychain once, then set only the account name in env:
+The plugin signs transactions by shelling out to the [proton CLI](https://www.npmjs.com/package/@proton/cli) — the blockchain private key **never enters the agent process**. Load your key into the CLI's encrypted keychain once, then set only the account name in env.
+
+### Keychain setup (one-time)
 
 ```bash
-# One-time keychain setup
+# 1. Install the CLI
 npm i -g @proton/cli
-proton chain:set proton                  # or proton-test
+
+# If `proton: command not found` after install, npm's global bin
+# isn't on your PATH. Fix it (and add to your shell rc):
+#   export PATH="$(npm config get prefix)/bin:$PATH"
+
+# 2. Point at the chain
+proton chain:set proton                  # mainnet (use `proton-test` for testnet)
+
+# 3. Don't have an XPR account yet?
+proton account:create myagent            # or sign up at https://webauth.com
+
+# 4. Load the key (interactive — pastes are hidden)
 proton key:add                           # paste your PVT_K1_ key; stored encrypted
-# Or for hosted consoles without a real TTY:
+
+# Or non-interactive (for hosted consoles without a real TTY).
+# The "no" answers the "encrypt this keychain with a password?" prompt —
+# pastes the key as-is, no extra password to remember:
 #   echo "no" | proton key:add PVT_K1_yourkey
+
+# 5. Verify
+proton key:list                          # shows your account + public key
+
+# If proton key:list shows the key but every signed action prompts for
+# a 32-character password: the keychain is encrypted. Unlock it once:
+#   proton key:unlock <your-keychain-password>
 ```
 
+### Required environment variables
+
+```env
+XPR_ACCOUNT=myagent                       # REQUIRED — without this, the plugin
+                                          # loads in read-only mode and every
+                                          # write tool silently fails. Look for
+                                          # `[xpr-agents] Read-only mode:` in
+                                          # logs to diagnose.
+XPR_NETWORK=mainnet                       # mainnet | testnet  (default: mainnet)
+```
+
+### Optional environment variables
+
 ```env
-XPR_ACCOUNT=myagent
-XPR_NETWORK=mainnet                       # or testnet
-XPR_RPC_ENDPOINT=https://proton.eosusa.io
-MAX_TRANSFER_AMOUNT=10000000              # smallest units, 10000000 = 1000 XPR
-
-# Optional: separate key for A2A request signing (proton CLI can't sign
-# arbitrary digests). Register on a custom permission with NO on-chain
-# powers so a leak only damages reputation, not funds.
+# RPC endpoint. Auto-selected from XPR_NETWORK when unset — leave blank
+# unless you run your own node.
+# XPR_RPC_ENDPOINT=https://proton.eosusa.io   # mainnet
+# XPR_RPC_ENDPOINT=https://tn1.protonnz.com   # testnet
+
+# Indexer URL. 4 tools (xpr_search_agents, xpr_get_events, xpr_get_stats,
+# xpr_indexer_health) depend on this. Defaults to the public XPR Agents
+# indexer — override only if you run your own.
+INDEXER_URL=https://indexer.xpragents.com
+
+# Safety caps. Defaults shown — adjust at your own risk.
+MAX_TRANSFER_AMOUNT=10000000              # 10000000 = 1000 XPR; caps every
+                                          # signed XPR transfer / stake / fee
+# confirmHighRisk=true (in plugin config) — 11 destructive tools (slash,
+# admin removal, high-value transfers, etc.) require `confirmed: true` in
+# the tool call to actually execute. Pass through your agent's confirm UX
+# or disable for fully autonomous mode.
+
+# A2A outbound signing key. Without this, the 5 xpr_a2a_* tools cannot
+# sign outbound calls (incoming A2A still works). The proton CLI can't
+# sign arbitrary HTTP digests so this key has to live in-process —
+# register it on a CUSTOM PERMISSION with NO token transfer authority
+# so a leak only damages reputation, not funds. See docs/A2A.md for the
+# proton CLI commands to create the permission.
 # A2A_SIGNING_KEY=PVT_K1_a2a_only_key
+
+# Shellbook write tools (shell_create_post, shell_comment, etc.)
+# require this. Read tools (shell_list_posts, shell_search, ...) don't.
+# SHELLBOOK_API_KEY=sb_...
 ```
 
 > **There is no `XPR_PRIVATE_KEY` env var.** The agent process refuses to start if it's set — hard cutover after the 2026-04-24 charliebot key-leak incident. See [`docs/A2A.md`](https://github.com/XPRNetwork/xpr-agents/blob/main/docs/A2A.md) for the A2A signing key model.

package/openclaw.plugin.json

@@ -15,7 +15,8 @@
       },
       "indexerUrl": {
         "type": "string",
-        "default": "http://localhost:3001"
+        "default": "https://indexer.xpragents.com",
+        "description": "Public XPR Agents indexer URL. Mainnet: https://indexer.xpragents.com, Testnet: https://testnet-indexer.xpragents.com. Override only if you run your own indexer."
       },
       "contracts": {
         "type": "object",
@@ -42,5 +43,19 @@
     "indexerUrl": { "label": "Indexer URL" },
     "confirmHighRisk": { "label": "Confirm High-Risk Actions" }
   },
-  "skills": ["skills/xpr-agent-operator"]
+  "skills": [
+    "skills/xpr-agent-operator",
+    "skills/creative",
+    "skills/web-scraping",
+    "skills/code-sandbox",
+    "skills/structured-data",
+    "skills/defi",
+    "skills/nft",
+    "skills/tax",
+    "skills/lending",
+    "skills/governance",
+    "skills/xmd",
+    "skills/smart-contracts",
+    "skills/shellbook"
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xpr-agents/openclaw",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "OpenClaw plugin for XPR Network Trustless Agent Registry - autonomous agent operation, escrow jobs, feedback, and validation",
   "author": "XPR Network",
   "repository": {
@@ -33,8 +33,10 @@
     ]
   },
   "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
+    "build": "npm run build:plugin && npm run build:skills",
+    "build:plugin": "tsc",
+    "build:skills": "node scripts/build-skills.mjs",
+    "clean": "rm -rf dist skills/*/dist",
     "dev": "tsc --watch",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -42,7 +44,8 @@
   },
   "dependencies": {
     "@xpr-agents/sdk": "^0.2.0",
-    "@proton/js": "^28.1.2"
+    "@proton/js": "^28.1.2",
+    "@shellbook/sdk": "^0.2.4"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/skills/code-sandbox/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: code-sandbox
+description: Execute JavaScript code in a sandboxed VM for data processing and computation
+---
+
+## Code Sandbox
+
+You have sandboxed JavaScript execution tools for computation and data processing:
+
+**Full scripts:**
+- `execute_js` — run JavaScript code in an isolated V8 sandbox
+  - Pass data via the `input` parameter (JSON) — access it as `INPUT` in your code
+  - Use `console.log()` to capture intermediate values (returned in `logs` array)
+  - Available globals: `JSON`, `Math`, `Date`, `Array`, `Object`, `String`, `Number`, `RegExp`, `Map`, `Set`, `parseInt`, `parseFloat`, `isNaN`, `isFinite`, `encodeURIComponent`, `decodeURIComponent`, `atob`, `btoa`
+  - No network access, no filesystem, no imports — pure computation only
+  - Default timeout 5 seconds, max 30 seconds
+  - 10MB output limit
+
+**Quick expressions:**
+- `eval_expression` — evaluate a single JavaScript expression and return the result
+  - Use for quick math: `"15 * 4500 * 0.01"` → `675`
+  - Date calculations: `"new Date().toISOString()"`
+  - Array operations: `"[1,2,3].map(x => x*x)"` → `[1, 4, 9]`
+
+**Best practices:**
+- Use `execute_js` for multi-step data processing, algorithm testing, code validation
+- Use `eval_expression` for quick math, string ops, date calculations
+- Pass large datasets via `input` parameter rather than embedding in code
+- Combine with `parse_csv` (structured-data skill) for CSV → transform → output workflows
+- Combine with `store_deliverable` to save computed results as job evidence

package/skills/code-sandbox/skill.json

@@ -0,0 +1,13 @@
+{
+  "name": "code-sandbox",
+  "version": "1.0.0",
+  "description": "Execute JavaScript code in a sandboxed V8 context using Node.js vm module",
+  "author": "xpr-agents",
+  "category": "compute",
+  "tags": ["code", "javascript", "sandbox", "vm", "compute"],
+  "capabilities": ["code-execution", "computation"],
+  "tools": ["execute_js", "eval_expression"],
+  "requires": {
+    "env": []
+  }
+}

package/skills/code-sandbox/src/index.ts

@@ -0,0 +1,212 @@
+/**
+ * Code Sandbox Skill — execute JavaScript in a sandboxed V8 context
+ *
+ * Zero external dependencies — uses Node.js built-in `vm` module.
+ */
+
+import vm from 'vm';
+
+interface ToolDef {
+  name: string;
+  description: string;
+  parameters: { type: 'object'; required?: string[]; properties: Record<string, unknown> };
+  handler: (params: any) => Promise<unknown>;
+}
+
+interface SkillApi {
+  registerTool(tool: ToolDef): void;
+  getConfig(): Record<string, unknown>;
+}
+
+// ── Constants ───────────────────────────────────
+
+const DEFAULT_TIMEOUT = 5000;
+const MAX_TIMEOUT = 30000;
+const MAX_OUTPUT_SIZE = 10 * 1024 * 1024; // 10MB
+
+// ── Sandbox helpers ─────────────────────────────
+
+function createSandboxGlobals(input: unknown, logs: string[]): Record<string, unknown> {
+  // Capture console methods
+  const consoleMock = {
+    log: (...args: unknown[]) => {
+      logs.push(args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '));
+    },
+    warn: (...args: unknown[]) => {
+      logs.push('[warn] ' + args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '));
+    },
+    error: (...args: unknown[]) => {
+      logs.push('[error] ' + args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' '));
+    },
+  };
+
+  return {
+    INPUT: input,
+    console: consoleMock,
+    JSON,
+    Math,
+    Date,
+    Array,
+    Object,
+    String,
+    Number,
+    RegExp,
+    Map,
+    Set,
+    parseInt,
+    parseFloat,
+    isNaN,
+    isFinite,
+    encodeURIComponent,
+    decodeURIComponent,
+    atob: (s: string) => Buffer.from(s, 'base64').toString('binary'),
+    btoa: (s: string) => Buffer.from(s, 'binary').toString('base64'),
+    // Explicitly undefined — blocked
+    require: undefined,
+    process: undefined,
+    globalThis: undefined,
+    global: undefined,
+  };
+}
+
+function serializeResult(value: unknown): string {
+  if (value === undefined) return 'undefined';
+  try {
+    const str = JSON.stringify(value, null, 2);
+    if (str.length > MAX_OUTPUT_SIZE) {
+      return str.slice(0, MAX_OUTPUT_SIZE) + '\n... [truncated at 10MB]';
+    }
+    return str;
+  } catch {
+    return String(value);
+  }
+}
+
+// ── Skill entry point ───────────────────────────
+
+export default function codeSandboxSkill(api: SkillApi): void {
+  // ── execute_js ──
+  api.registerTool({
+    name: 'execute_js',
+    description: [
+      'Run JavaScript code in a sandboxed V8 context.',
+      'Pass data via "input" (JSON), access it as INPUT in code.',
+      'console.log/warn/error are captured in the "logs" array.',
+      'Available: JSON, Math, Date, Array, Object, String, Number, RegExp, Map, Set,',
+      'parseInt, parseFloat, isNaN, isFinite, encodeURIComponent, decodeURIComponent, atob, btoa.',
+      'No network, filesystem, require, or import access. Max 30s timeout, 10MB output.',
+    ].join(' '),
+    parameters: {
+      type: 'object',
+      required: ['code'],
+      properties: {
+        code: { type: 'string', description: 'JavaScript code to execute. The last expression value is returned as the result.' },
+        input: { description: 'Optional JSON data available as INPUT in the code.' },
+        timeout: { type: 'number', description: 'Execution timeout in milliseconds (default 5000, max 30000).' },
+      },
+    },
+    handler: async ({ code, input, timeout }: {
+      code: string; input?: unknown; timeout?: number;
+    }) => {
+      if (!code || typeof code !== 'string') {
+        return { error: 'code parameter is required and must be a string' };
+      }
+
+      const timeoutMs = Math.min(Math.max(timeout || DEFAULT_TIMEOUT, 100), MAX_TIMEOUT);
+      const logs: string[] = [];
+      const startTime = Date.now();
+
+      try {
+        const globals = createSandboxGlobals(input, logs);
+        const context = vm.createContext(globals, {
+          codeGeneration: { strings: false, wasm: false },
+        });
+
+        // Wrap code so the last expression is returned
+        const wrapped = `(function() {\n${code}\n})()`;
+        const script = new vm.Script(wrapped, { filename: 'sandbox.js' });
+        const result = script.runInContext(context, { timeout: timeoutMs });
+        const durationMs = Date.now() - startTime;
+
+        const serialized = serializeResult(result);
+        if (serialized.length > MAX_OUTPUT_SIZE) {
+          return {
+            result: serialized.slice(0, 1000) + '... [truncated]',
+            logs,
+            duration_ms: durationMs,
+            warning: 'Output exceeded 10MB limit and was truncated',
+          };
+        }
+
+        // Parse back to preserve types (arrays, objects)
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(serialized);
+        } catch {
+          parsed = serialized === 'undefined' ? undefined : serialized;
+        }
+
+        return { result: parsed, logs, duration_ms: durationMs };
+      } catch (err: any) {
+        const durationMs = Date.now() - startTime;
+        const message = err.message || String(err);
+
+        // Provide helpful error context
+        if (message.includes('Script execution timed out')) {
+          return { error: `Execution timed out after ${timeoutMs}ms. Keep code efficient or increase timeout (max ${MAX_TIMEOUT}ms).`, logs, duration_ms: durationMs };
+        }
+        if (message.includes('Code generation from strings disallowed')) {
+          return { error: 'eval() and Function() constructor are blocked in the sandbox. Use direct code instead.', logs, duration_ms: durationMs };
+        }
+
+        return { error: message, logs, duration_ms: durationMs };
+      }
+    },
+  });
+
+  // ── eval_expression ──
+  api.registerTool({
+    name: 'eval_expression',
+    description: [
+      'Evaluate a single JavaScript expression and return the result.',
+      'Lightweight alternative to execute_js for quick calculations.',
+      'Examples: "15 * 4500 * 0.01", "new Date().toISOString()", "[1,2,3].map(x => x*x)".',
+    ].join(' '),
+    parameters: {
+      type: 'object',
+      required: ['expression'],
+      properties: {
+        expression: { type: 'string', description: 'A JavaScript expression to evaluate.' },
+      },
+    },
+    handler: async ({ expression }: { expression: string }) => {
+      if (!expression || typeof expression !== 'string') {
+        return { error: 'expression parameter is required and must be a string' };
+      }
+
+      try {
+        const globals = createSandboxGlobals(undefined, []);
+        const context = vm.createContext(globals, {
+          codeGeneration: { strings: false, wasm: false },
+        });
+
+        const script = new vm.Script(`(${expression})`, { filename: 'expr.js' });
+        const result = script.runInContext(context, { timeout: DEFAULT_TIMEOUT });
+
+        let serialized: unknown;
+        try {
+          serialized = JSON.parse(JSON.stringify(result));
+        } catch {
+          serialized = String(result);
+        }
+
+        return {
+          result: serialized,
+          type: result === null ? 'null' : Array.isArray(result) ? 'array' : typeof result,
+        };
+      } catch (err: any) {
+        return { error: err.message || String(err) };
+      }
+    },
+  });
+}

package/skills/creative/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: creative
+description: Creative deliverable tools for AI agents
+---
+## Creative Deliverables
+
+You have powerful creative capabilities for delivering job results:
+
+**Text & Documents:**
+- `store_deliverable` with content_type "text/markdown" — rich Markdown (default)
+- `store_deliverable` with content_type "application/pdf" — write Markdown, auto-generates PDF
+  - Use ![alt text](https://image-url) to embed images — they are downloaded and embedded in the PDF
+  - Write CLEAN Markdown only — no HTML tags, no <cite> tags, no raw HTML
+- `store_deliverable` with content_type "text/csv" — structured data
+
+**Images (AI-generated) — IMPORTANT:**
+- Call `generate_image` with prompt AND job_id — it generates, uploads to IPFS, and returns evidence_uri in ONE step
+- Then just call `xpr_deliver_job` with the evidence_uri
+- Do NOT write markdown descriptions of images — generate the actual image!
+
+**Video (AI-generated):**
+- Call `generate_video` with prompt AND job_id — generates, uploads to IPFS, returns evidence_uri
+- Then call `xpr_deliver_job` with the evidence_uri
+
+**Images/Media from the web:**
+- Use `web_search` to find suitable content, then `store_deliverable` with source_url
+
+**Code repositories:**
+- `create_github_repo` with all source files — creates a public GitHub repo
+
+NEVER say you can't create images or videos — you have the tools!
+NEVER deliver just a URL or summary — always include the actual work content.

package/skills/creative/skill.json

@@ -0,0 +1,13 @@
+{
+  "name": "creative",
+  "version": "1.0.0",
+  "description": "AI image/video generation, PDF creation, GitHub repo delivery, and IPFS storage for job deliverables",
+  "author": "xpr-agents",
+  "category": "ai",
+  "tags": ["image", "video", "pdf", "github", "ipfs", "deliverables"],
+  "capabilities": ["image-generation", "video-generation", "pdf-generation", "github-repos", "ipfs-storage"],
+  "tools": ["store_deliverable", "create_github_repo", "generate_image", "generate_video"],
+  "requires": {
+    "env": []
+  }
+}