Skip to main content
Glama

sora_get_tasks_batch

Query multiple video generation tasks in a single request to check their status and retrieve video information efficiently for batch tracking.

Instructions

Query multiple video generation tasks at once.

Efficiently check the status of multiple tasks in a single request.
More efficient than calling sora_get_task multiple times.

Use this when:
- You have multiple pending generations to check
- You want to get status of several videos at once
- You're tracking a batch of generations

Returns:
    Status and video information for all queried tasks.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
task_idsYesList of task IDs to query. Maximum recommended batch size is 50 tasks.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • The async handler function for the 'sora_get_tasks_batch' MCP tool. It accepts a list of task IDs, calls client.query_task with ids and action='retrieve_batch', and returns the formatted result.
    @mcp.tool()
    async def sora_get_tasks_batch(
        task_ids: Annotated[
            list[str],
            Field(description="List of task IDs to query. Maximum recommended batch size is 50 tasks."),
        ],
    ) -> str:
        """Query multiple video generation tasks at once.
    
        Efficiently check the status of multiple tasks in a single request.
        More efficient than calling sora_get_task multiple times.
    
        Use this when:
        - You have multiple pending generations to check
        - You want to get status of several videos at once
        - You're tracking a batch of generations
    
        Returns:
            Status and video information for all queried tasks.
        """
        result = await client.query_task(
            ids=task_ids,
            action="retrieve_batch",
        )
        return format_batch_task_result(result)
  • The @mcp.tool() decorator registers 'sora_get_tasks_batch' (and 'sora_get_task') as MCP tools. The function name becomes the tool name.
    @mcp.tool()
  • The 'format_batch_task_result' helper function that formats the batch query result as a pretty-printed JSON string.
    def format_batch_task_result(data: dict[str, Any]) -> str:
        """Format batch task query result as JSON.
    
        Args:
            data: API response dictionary
    
        Returns:
            JSON string representation of the result
        """
        return json.dumps(data, ensure_ascii=False, indent=2)
  • The 'query_task' method on the SoraClient class. The batch tool calls this with ids=task_ids and action='retrieve_batch', which sends a POST to the /sora/tasks endpoint.
    async def query_task(self, **kwargs: Any) -> dict[str, Any]:
        """Query task status using the tasks endpoint."""
        task_id = kwargs.get("id") or kwargs.get("ids", [])
        logger.info(f"🔍 Querying task(s): {task_id}")
        return await self.request("/sora/tasks", kwargs)
  • The 'format_video_result' helper references 'sora_get_tasks_batch' as the batch_poll_tool for async submission guidance.
    _with_submission_guidance(data, "sora_get_task", "sora_get_tasks_batch"),
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description bears full behavioral disclosure burden. It states the return type (status and video information) and implies a read-only operation. The parameter description also mentions a max batch size of 50, which is a key constraint. However, it lacks details on error handling or behavior with invalid task IDs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concisely structured with a clear purpose statement, efficiency comparison, bullet-pointed usage scenarios, and a return statement. No extraneous information is present, and each sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple single-parameter nature and existing output schema, the description adequately covers purpose, usage context, and return type. It is mostly complete but could mention behavior for non-existent task IDs or error responses to be fully robust.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with a clear parameter description including a batch size recommendation. The tool description adds no further parameter meaning beyond what the schema provides, earning the baseline score of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool queries multiple video generation tasks at once, using a specific verb and resource. It distinguishes itself from the sibling sora_get_task by highlighting efficiency and batch capability.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit 'Use this when:' bullet points listing scenarios like checking multiple pending generations. It also contrasts with sora_get_task by noting this is more efficient for batches, offering clear usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AceDataCloud/SoraMCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server