Using the Playground

Test integrations, execute actions, and run code in the Weavz developer console.

The Playground is a unified developer console for testing integrations, executing actions, and running sandboxed code — all from the Weavz dashboard. It has 4 tabs: Actions, Triggers, MCP, and Code.

Workspace Selection

Before using the Playground, select a workspace from the dropdown at the top. A workspace is required — there is no "All workspaces" option. The selected workspace determines which connections, storage, KV data, and input partials are available.

Playground usage is excluded from billing quotas by default. Use it freely for testing and development without worrying about action counts.

Actions Tab

Execute any integration action interactively:

Open the Playground

Navigate to Playground from the dashboard sidebar.

Select an integration

Choose the integration you want to test (e.g., Slack, GitHub, OpenAI).

Choose an action

Pick the specific action to execute (e.g., send_channel_message, create_issue).

Fill in inputs

The form dynamically renders the action's input schema. Fill in the required fields — select inputs fetch available values from the connected service.

Select a connection

Choose which connection to authenticate with. If you have multiple connections for the same integration, pick the one you want to test.

Execute and inspect

Click Execute and view the full response payload, including output data and any errors.

The Actions tab supports all integrations, including the built-in Storage and KV Store integrations. You can read/write files and key-value data directly from the Playground.

Triggers Tab

Test trigger configurations with sample payloads before enabling them in production:

Select an integration and trigger

Choose an integration (e.g., GitHub) and pick the trigger event you want to test (e.g., new_push, new_issue).

Provide inputs and connection

Fill in any required trigger inputs and select the connection to authenticate with.

View sample payload

Click Test to retrieve a sample event payload. This shows the exact shape of data your callback URL will receive when the trigger fires in production.

Use this to validate your webhook handler before enabling a trigger. See Setting Up Triggers for the full trigger workflow.

MCP Tab

Test MCP server connections using the JSON-RPC protocol:

Select an MCP server

Choose an existing MCP server from the dropdown. Both TOOLS and CODE mode servers are supported.

List available tools

Send a tools/list request to see all tools registered on the server. For CODE mode servers, this shows the 3 meta-tools (weavz_search, weavz_read_api, weavz_execute).

Call a tool

Send a tools/call request with the tool name and arguments. View the full JSON-RPC request and response, including any errors.

This is useful for debugging MCP tool configurations, verifying tool schemas, and testing tool execution without connecting an AI client.

Code Tab

Write and execute sandboxed JavaScript using the weavz.* API surface:

Write code

Author JavaScript code in the editor. All integrations registered on your workspace are available via await weavz.{integration}.{action}({...}).

Execute

Click Run to execute the code in a sandboxed environment. The execution is isolated and secure.

View results

Inspect the return value, console output, and execution trace. The trace shows every integration action called, its duration, and success status.

The Code tab is ideal for prototyping multi-step workflows before deploying them to a CODE mode MCP server. You can chain multiple integration calls, process data between services, and test complex logic interactively.

javascript

// Example: Fetch issues and post a summary to Slack
const issues = await weavz.github.list_issues({
  repo: 'acme/backend',
  state: 'open',
})
 
await weavz.slack.send_channel_message({
  channel: '#engineering',
  text: `Open issues: ${issues.length}`,
})
 
return { count: issues.length }

Input Partials

Input partials are saved parameter presets that pre-fill action inputs. They are scoped to a workspace and can be assigned to specific integrations or individual actions.

How Partials Work

A partial contains a set of key-value pairs that are merged into the action input at execution time. Some keys can be marked as enforced, meaning they cannot be overridden — the partial's value always takes precedence.

The merge order is:

Input defaults -- default values defined by the action schema
Partial non-enforced values -- preset values that can be overridden
Runtime input -- values you provide at execution time
Enforced values -- partial values that always win

Saving Partials from the Playground

When working in the Actions tab, you can save the current input values as a partial:

Fill in inputs

Enter the action parameters you want to save as a preset.

Save as partial

Click Save Partial. Give the partial a name and optionally mark specific keys as enforced.

Reuse later

The next time you select the same integration and action, you can load the saved partial from the dropdown to pre-fill the form.

Loading Partials

When a partial is available for the current integration and action, a dropdown appears above the input form. Select a partial to pre-fill the inputs. Enforced keys are shown as locked and cannot be edited.

Partials can also be assigned to MCP server tools. When a partial is assigned, its enforced keys are stripped from the tool's input schema — the AI agent never sees or needs to provide those values.

Managing Partials

To manage all partials for a workspace, navigate to Partials in the dashboard sidebar. From there you can:

View all saved partials grouped by integration and action
Edit partial values and enforced keys
Delete partials you no longer need
Create new partials scoped to a specific integration or integration + action combination

Partials are also available via the Partials API for programmatic management.