home / skills / composiohq / awesome-claude-skills / callpage-automation

callpage-automation skill

/callpage-automation

This skill automates Callpage tasks through Rube MCP, prioritizing live tool schemas to streamline connections, tool discovery, and execution workflows.

npx playbooks add skill composiohq/awesome-claude-skills --skill callpage-automation

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.9 KB

---
name: callpage-automation
description: "Automate Callpage tasks via Rube MCP (Composio). Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Callpage Automation via Rube MCP

Automate Callpage operations through Composio's Callpage toolkit via Rube MCP.

**Toolkit docs**: [composio.dev/toolkits/callpage](https://composio.dev/toolkits/callpage)

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Callpage connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `callpage`
- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas

## Setup

**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.

1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `callpage`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows

## Tool Discovery

Always discover available tools before executing workflows:

```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Callpage operations", known_fields: ""}]
session: {generate_id: true}
```

This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.

## Core Workflow Pattern

### Step 1: Discover Available Tools

```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Callpage task"}]
session: {id: "existing_session_id"}
```

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["callpage"]
session_id: "your_session_id"
```

### Step 3: Execute Tools

```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
  tool_slug: "TOOL_SLUG_FROM_SEARCH",
  arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```

## Known Pitfalls

- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
- **Schema compliance**: Use exact field names and types from the search results
- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
- **Pagination**: Check responses for pagination tokens and continue fetching until complete

## Quick Reference

| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Callpage-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `callpage` |
| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |

---
*Powered by [Composio](https://composio.dev)*

Overview

This skill automates Callpage tasks through Composio’s Callpage toolkit using a Rube MCP connection. It guides tool discovery, connection validation, and executing composio tools programmatically while enforcing schema compliance and session management. Use it to reliably run Callpage operations, bulk tasks, and workflows inside an agent environment.

How this skill works

The skill first calls RUBE_SEARCH_TOOLS to discover current tool slugs and input schemas for Callpage operations. It then validates or establishes the Callpage connection via RUBE_MANAGE_CONNECTIONS and runs one or more tools using RUBE_MULTI_EXECUTE_TOOL (or RUBE_REMOTE_WORKBENCH for bulk runs), always including memory and a session_id. The skill enforces schema-driven arguments, pagination handling, and session reuse patterns to avoid failures from changing tool definitions.

When to use it

Automating Callpage account or campaign management tasks
Running bulk Callpage operations or scheduled workflows
Integrating Callpage actions into larger agent-driven processes
When tool schemas or available operations can change frequently
When you need reliable session and connection validation before execution

Best practices

Always call RUBE_SEARCH_TOOLS first; never hardcode tool slugs or argument shapes
Verify Callpage connection status with RUBE_MANAGE_CONNECTIONS and ensure it is ACTIVE before running tools
Pass the exact fields and types returned in the search schema; validate input against schemaRef if present
Include a memory object in every RUBE_MULTI_EXECUTE_TOOL call, even if empty
Reuse a session_id for related workflow steps; generate a new session for unrelated workflows
Check responses for pagination tokens and loop until all pages are fetched

Example use cases

Discover available Callpage tools and list required arguments for a given task
Validate and activate a Callpage connection, then update campaign settings programmatically
Execute multiple Callpage toolkit actions in a single RUBE_MULTI_EXECUTE_TOOL call for a composite workflow
Run bulk updates or migrations using RUBE_REMOTE_WORKBENCH with run_composio_tool()
Fetch full schemas for complex tools via RUBE_GET_TOOL_SCHEMAS and generate validated inputs automatically

FAQ

What should I do if RUBE_SEARCH_TOOLS returns a different schema than expected?

Treat the returned schema as authoritative: adapt your arguments to the new fields/types and re-run validation. Never proceed using cached schemas.

Is authentication required to use Rube MCP with Callpage?

No API keys are needed for Rube MCP itself, but the Callpage toolkit must be connected via RUBE_MANAGE_CONNECTIONS and the connection must be ACTIVE; follow any returned auth link if needed.