home / skills / composiohq / awesome-claude-skills / short-io-automation

short-io-automation skill

safe

/short-io-automation

This skill automates Short IO tasks via Rube MCP, discovering tool schemas before execution to ensure up-to-date tools.

npx playbooks add skill composiohq/awesome-claude-skills --skill short-io-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: short-io-automation
description: "Automate Short IO tasks via Rube MCP (Composio). Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Short IO Automation via Rube MCP

Automate Short IO operations through Composio's Short IO toolkit via Rube MCP.

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

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Short IO connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `short_io`
- 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 `short_io`
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: "Short IO 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 Short IO task"}]
session: {id: "existing_session_id"}
```

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["short_io"]
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 Short IO-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `short_io` |
| 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 Short IO tasks through Composio's Short IO toolkit using Rube MCP. It guides tool discovery, connection checks, and safe execution patterns so workflows run reliably. The skill emphasizes always searching tools first to get current schemas and session-aware execution.

How this skill works

The skill orchestrates three phases: discover available Short IO tools with RUBE_SEARCH_TOOLS, verify an active Short IO connection via RUBE_MANAGE_CONNECTIONS, and run the selected tool(s) with RUBE_MULTI_EXECUTE_TOOL or RUBE_REMOTE_WORKBENCH. It always requests live tool schemas before constructing arguments and mandates including a memory object and a consistent session_id for each workflow. It also handles pagination and schema resolution using RUBE_GET_TOOL_SCHEMAS when needed.

When to use it

Automate link creation, redirects, or URL management in Short IO at scale
Integrate Short IO operations into larger agent workflows via Rube MCP/Composio
Run bulk Short IO tasks using RUBE_REMOTE_WORKBENCH or multi-execute patterns
When you need up-to-date tool schemas to avoid breaking changes
During CI or scheduled jobs that require session-based idempotent runs

Best practices

Always call RUBE_SEARCH_TOOLS first to retrieve current tool slugs and input schemas before building arguments
Confirm toolkit connection with RUBE_MANAGE_CONNECTIONS and ensure status is ACTIVE before executing tools
Include a memory object (can be {}) in every RUBE_MULTI_EXECUTE_TOOL request
Reuse a session_id across a logical workflow; generate a new session_id for a new workflow
Respect exact field names and data types from the discovered schema; never hardcode request shapes
Check responses for pagination tokens and fetch subsequent pages until complete

Example use cases

Create or update Short IO links programmatically after discovering the correct create/update tool schema
Bulk migrate or sync URL redirects using RUBE_REMOTE_WORKBENCH run_composio_tool patterns
Automate Short IO connection validation and report active/inactive status for monitoring
Compose multi-step workflows: search tools, validate connection, then call RUBE_MULTI_EXECUTE_TOOL for a sequence of Short IO operations

FAQ

What is the first API I must call?

Always call RUBE_SEARCH_TOOLS first to fetch available tool slugs and their input schemas for your Short IO use case.

What if my connection shows INACTIVE?

Use RUBE_MANAGE_CONNECTIONS to get the auth link returned by the call, complete the auth flow, then confirm the connection shows ACTIVE before executing tools.