Developer documentation

Build with Space Bunny Alpha

Use Space Bunny Alpha through OpenRouter for long-context reasoning, multimodal input, JSON responses and tool-enabled agent workflows.

Model overview

A long-context multimodal reasoning model

Space Bunny Alpha is an anonymous preview model on OpenRouter. It accepts text, images and video, returns text, supports tool calling and JSON output, and exposes a one-million-token context window with up to 524,288 completion tokens.

1M-token context window

Text, image and video input

Five reasoning-effort levels

Quickstart

Send your first OpenRouter request

Start in the Playground, then move the same chat-completion shape behind your server with an OpenRouter API key.

  1. 1

    Open the playground

    Sign in and test a real prompt with low reasoning effort before adding more context.

  2. 2

    Create an OpenRouter key

    Store the key in a server-side environment variable. Never expose it in browser code.

  3. 3

    Send chat messages

    Use model stealth/space-bunny-alpha with a standard system, user and assistant message history.

  4. 4

    Add advanced controls

    Introduce reasoning effort, multimodal parts, tools or JSON output only when the workflow needs them.

Input modalities

Mix text with visual context

A user message can be a text string or an ordered content array. Put the text instruction first, then append image or video URL parts.

text

Prompts, documents, code and conversation history

image

Public URLs or base64 data URLs for PNG, JPEG, WebP and GIF

video

Public or base64 video URLs supported by the active provider route

Space Bunny Alpha returns text. Video URL compatibility can vary by provider, so verify the exact route before production use.

Request controls

Control depth, modalities and tools

Keep the core request small: choose the model, provide messages, then add only the controls needed by the current task.

CapabilityUse it forRequest fields
Reasoning effort
Balance response depth and latencyreasoning.effort
Multimodal input
Understand screenshots, diagrams and videoimage_url · video_url
Tool calling
Let an agent request approved functionstools · tool_choice · tool_calls

Core request fields

Every request selects a model and provides at least one message. Reasoning settings are optional in the API shape but recommended here so the provider default does not surprise you.

model

Required string. Use stealth/space-bunny-alpha.

messages

Required array. Ordered system, user, assistant and tool messages that form the conversation.

reasoning

Optional object. Set effort to low, medium, high, xhigh or max.

{
  "model": "stealth/space-bunny-alpha",
  "messages": [
    { "role": "user", "content": "Review this API design." }
  ],
  "reasoning": { "effort": "low" }
}

For machine-readable output, ask explicitly for JSON and set response_format to json_object. JSON Schema enforcement is not currently listed for this model, so validate the result in your application.

{
  "messages": [
    { "role": "user", "content": "Return a JSON launch plan." }
  ],
  "response_format": { "type": "json_object" }
}

Reasoning effort

Reasoning is mandatory for Space Bunny Alpha. OpenRouter lists low, medium, high, xhigh and max; the provider currently defaults to max when no effort is supplied. Start at low and increase it only when the task benefits from deeper reasoning.

{
  "model": "stealth/space-bunny-alpha",
  "messages": [{ "role": "user", "content": "Find the safest migration plan." }],
  "reasoning": { "effort": "high" }
}

Multimodal input

Use an ordered content array inside a user message. Send the text instruction first, followed by one or more image_url or video_url parts. URLs must be reachable by the upstream provider, or use a supported base64 data URL.

{
  "role": "user",
  "content": [
    { "type": "text", "text": "Review this interface hierarchy." },
    { "type": "image_url", "image_url": { "url": "https://example.com/ui.png" } }
  ]
}

Tool calling

Describe each function and its JSON parameters in tools. The model may request a call, but your application must validate the name, arguments, permissions and side effects before execution.

{
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_record",
      "description": "Fetch one approved record",
      "parameters": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] }
    }
  }],
  "tool_choice": "auto"
}

Output

Read the assistant message and usage

A successful non-streaming response contains choices. The first choice normally carries the assistant message, while usage reports prompt, completion and total tokens.

  • message: Read choices[0].message.content for text or JSON, and message.tool_calls when the model requests a function.
  • usage: Includes prompt_tokens, completion_tokens and total_tokens; OpenRouter may also include cost details.
  • elapsedMs: Space Bunny's proxy adds end-to-end request time in milliseconds for Playground responses.

Reasoning tokens can count toward completion usage even when internal reasoning is not shown in the final message.

Response fields

modelThe model that served the response.
choicesCompletion choices containing message, index and finish_reason.
usageToken usage and optional OpenRouter cost metadata.
elapsedEnd-to-end time added by this project's Playground proxy, not a native OpenRouter field.

Response example

{
  "id": "chatcmpl-123",
  "model": "stealth/space-bunny-alpha",
  "choices": [{
    "index": 0,
    "message": { "role": "assistant", "content": "Here is the migration plan..." },
    "finish_reason": "stop"
  }],
  "usage": { "prompt_tokens": 161, "completion_tokens": 42, "total_tokens": 203 }
}

Output patterns

Use plain text by default, request a JSON object when code needs structured data, or handle tool calls when an agent needs external capabilities.

Text response

The default assistant response for explanations, code review, analysis and long-form generation.

role

assistant for a model-generated message.

content

The response text, usually a string.

{
  "role": "assistant",
  "content": "The safest migration path is..."
}

JSON object

Set response_format to json_object and instruct the model to return valid JSON. Validate the parsed object yourself.

role

assistant for the generated response.

content

A string containing the JSON object; parse it after validation.

response_format

Request-side setting: { type: json_object }.

{
  "role": "assistant",
  "content": "{\"risk\":\"low\",\"steps\":[\"backup\",\"migrate\"]}"
}

Tool call

When tools are provided, the assistant may request one or more functions instead of returning the final answer immediately.

role

assistant for the tool-request message.

tool_calls

Array of requested function names and JSON arguments.

finish_reason

Often tool_calls when the response pauses for tool execution.

{
  "role": "assistant",
  "tool_calls": [{
    "id": "call_123",
    "type": "function",
    "function": { "name": "get_record", "arguments": "{\"id\":\"42\"}" }
  }]
}

Usage fields

input_tokens

integer · OpenRouter prompt_tokens: tokens consumed by the input.

output_tokens

integer · OpenRouter completion_tokens: generated output plus any counted reasoning tokens.

API reference

Create a chat completion

Send OpenAI-compatible chat requests to OpenRouter with the Space Bunny Alpha model ID.

Chat Completions endpoint

POST https://openrouter.ai/api/v1/chat/completions

Send an OpenRouter bearer key and application/json content type with every request.

Authorization: Bearer <OPENROUTER_API_KEY>
Content-Type: application/json
HTTP-Referer: https://your-app.example
X-OpenRouter-Title: Your App

Request body

model and messages are the core fields. Add reasoning, response_format, tools, temperature or output limits as the task requires.

modelstring · required. Use stealth/space-bunny-alpha.
messagesarray · required. Ordered chat history with at least one message.
reasoningobject · optional. Set effort to low, medium, high, xhigh or max.
response_formatobject · optional. Use { type: json_object } for JSON output; validate the result yourself.

Space Bunny Alpha also lists temperature, top_p, tools, tool_choice, max_tokens and include_reasoning among its supported parameters.

cURL example

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "stealth/space-bunny-alpha",
    "messages": [{ "role": "user", "content": "Review this design." }],
    "reasoning": { "effort": "low" },
    "max_completion_tokens": 2048
  }'

Request body example

{
  "model": "stealth/space-bunny-alpha",
  "messages": [
    { "role": "system", "content": "Be careful and concise." },
    { "role": "user", "content": "Review this design." }
  ],
  "reasoning": { "effort": "low" },
  "temperature": 0.7,
  "max_completion_tokens": 2048
}

Keep the OpenRouter key in a server-side secret. This project's Playground calls its own server route so the browser never receives the provider key.

Agent usage

Use Space Bunny Alpha in an agent

Point an OpenAI-compatible client at OpenRouter, provide only approved tools, and keep validation and execution authority in your application.

Configure the endpoint

Set the OpenRouter base URL, model ID and API key in server-side environment variables.

Choose effort per task

Use low for routine work and increase reasoning effort only for tasks that need deeper analysis.

Validate every tool call

Treat tool names and arguments as untrusted model output until your application checks them.

Configure the endpoint

export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
export OPENROUTER_API_KEY="sk-or-v1-..."
export OPENAI_MODEL="stealth/space-bunny-alpha"

Never paste a real key into source code, a public prompt, browser storage or an agent transcript. Use your platform's secret manager.

Five useful starting points

These prompts highlight long context, multimodal input, reasoning controls, structured output and tool safety.

1

Review a large codebase

Use the context window to connect architecture notes, relevant files and runtime evidence.

Review the supplied architecture notes, source files and incident logs. Identify the most likely failure boundary, cite the evidence for each conclusion, and propose the smallest safe fix. State what remains uncertain.
2

Guard a tool workflow

Let the model request approved tools while application permissions remain authoritative.

Use the available read-only tools to find the relevant customer record. Do not call destructive or payment tools. If a write would help, explain the proposed action and wait for explicit approval.
3

Tune reasoning effort

Start low for routine tasks and compare a higher effort only when the result needs deeper analysis.

Analyze this migration plan for hidden rollback risks. Separate certain findings from assumptions, then recommend whether low, medium or high reasoning effort is appropriate for the final review.
4

Analyze an interface image

Pair the prompt with an image URL to inspect hierarchy, accessibility and usability.

Review the attached interface screenshot. Identify the three highest-impact hierarchy or accessibility problems and propose concrete fixes without changing the product's visual identity.
5

Return a structured plan

Use JSON output for a plan that code can validate and hand to another workflow.

Return one valid JSON object with keys summary, risks, steps and verification. Do not use Markdown. Each step must include an owner and a measurable completion check.
The model can propose actions and request tools, but it does not own your credentials, permissions, policies or approval boundaries. Validate before every external side effect.

Error handling

Errors and retries

OpenRouter uses standard HTTP status codes and returns a JSON error body when a request fails.

StatusMeaning
400Bad Request: malformed JSON, unsupported parameters or an invalid message shape.
401Unauthorized: the OpenRouter API key is missing or invalid.
402Payment Required: the account has insufficient credits for a paid route. The current preview is listed at $0, but handle this status defensively.
429Too Many Requests: a rate limit was exceeded. Wait before retrying.
502Upstream failure: OpenRouter or the selected provider could not complete the request.

Retry 429 and transient 5xx errors with exponential backoff and jitter. Do not automatically retry invalid 400-series requests except rate limits.

What to do next

Run one real prompt in the Playground, then move the same request behind your server and add multimodal input, JSON or tools only as the workflow needs them.