Input Partials

Saved parameter presets with defaults and enforcement for actions and triggers.

Input Partials

Input partials are saved parameter configurations (presets) that you attach to actions and triggers. They let you pre-fill default values, lock down enforced values that cannot be overridden, and share configurations across your team.

How Partials Work

A partial is a named configuration scoped to a workspace and integration. It stores:

Values — key-value pairs that pre-fill action inputs
Enforced keys — a subset of those values that cannot be overridden at runtime
Scope — either integration-wide (applies to all actions) or action-specific

When you execute an action or enable a trigger, partials merge into the final input following a defined order.

Merge Order

When an action executes, inputs are merged in this order (each layer overrides the previous):

Input defaults — the integration's built-in default values
Partial values (non-enforced) — your preset values that users can override
Runtime input — the values provided at execution time
Enforced values — your preset values that cannot be overridden

This means enforced keys always win, regardless of what the caller passes.

Creating a Partial

bash

curl -X POST https://api.weavz.io/api/v1/partials \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "workspaceId": "proj_abc123",
    "integrationName": "slack",
    "actionName": "send_channel_message",
    "name": "General Channel Preset",
    "values": {
      "channel": "C01ABCDEF"
    },
    "enforcedKeys": ["channel"]
  }'

typescript

import { WeavzClient } from '@weavz/sdk'
 
const client = new WeavzClient({ apiKey: 'wvz_your_api_key' })
 
const { partial } = await client.partials.create({
  workspaceId: 'proj_abc123',
  integrationName: 'slack',
  actionName: 'send_channel_message',
  name: 'General Channel Preset',
  values: { channel: 'C01ABCDEF' },
  enforcedKeys: ['channel'],
})
 
console.log(`Created partial: ${partial.id}`)

python

from weavz_sdk import WeavzClient
 
client = WeavzClient(api_key="wvz_your_api_key")
 
result = client.partials.create(
    workspace_id="proj_abc123",
    integration_name="slack",
    action_name="send_channel_message",
    name="General Channel Preset",
    values={"channel": "C01ABCDEF"},
    enforced_keys=["channel"],
)
 
print(f"Created partial: {result['partial']['id']}")

typescript

const res = await fetch('https://api.weavz.io/api/v1/partials', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    workspaceId: 'proj_abc123',
    integrationName: 'slack',
    actionName: 'send_channel_message',
    name: 'General Channel Preset',
    values: { channel: 'C01ABCDEF' },
    enforcedKeys: ['channel'],
  }),
})
 
const { partial } = await res.json()
console.log(`Created partial: ${partial.id}`)

python

import httpx
 
res = httpx.post(
    "https://api.weavz.io/api/v1/partials",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "workspaceId": "proj_abc123",
        "integrationName": "slack",
        "actionName": "send_channel_message",
        "name": "General Channel Preset",
        "values": {"channel": "C01ABCDEF"},
        "enforcedKeys": ["channel"],
    },
)
 
partial = res.json()["partial"]
print(f"Created partial: {partial['id']}")

In this example, the channel field is both set as a value and listed in enforcedKeys. This means the channel is always C01ABCDEF and callers cannot override it.

Default Partials

Mark a partial as the default for its scope, and it applies automatically when no explicit partialIds are provided:

bash

curl -X POST https://api.weavz.io/api/v1/partials/{partialId}/set-default \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"isDefault": true}'

typescript

await client.partials.setDefault(partialId, true)

python

client.partials.set_default(partial_id, True)

typescript

await fetch(`https://api.weavz.io/api/v1/partials/${partialId}/set-default`, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ isDefault: true }),
})

python

httpx.post(
    f"https://api.weavz.io/api/v1/partials/{partial_id}/set-default",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={"isDefault": True},
)

Default partials auto-resolve in this order: action-specific default first, then integration-wide default. Up to 2 defaults can stack.

Using Partials with Actions

Pass partialIds when executing an action to apply specific partials:

bash

curl -X POST https://api.weavz.io/api/v1/actions/execute \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "integrationName": "slack",
    "actionName": "send_channel_message",
    "input": {
      "text": "Hello from Weavz!"
    },
    "workspaceId": "proj_abc123",
    "partialIds": ["partial_id_here"]
  }'

typescript

const { output } = await client.actions.execute('slack', 'send_channel_message', {
  input: { text: 'Hello from Weavz!' },
  workspaceId: 'proj_abc123',
  partialIds: ['partial_id_here'],
})

python

result = client.actions.execute(
    "slack",
    "send_channel_message",
    input={"text": "Hello from Weavz!"},
    workspace_id="proj_abc123",
    partial_ids=["partial_id_here"],
)

typescript

const res = await fetch('https://api.weavz.io/api/v1/actions/execute', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    integrationName: 'slack',
    actionName: 'send_channel_message',
    input: { text: 'Hello from Weavz!' },
    workspaceId: 'proj_abc123',
    partialIds: ['partial_id_here'],
  }),
})

python

res = httpx.post(
    "https://api.weavz.io/api/v1/actions/execute",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "integrationName": "slack",
        "actionName": "send_channel_message",
        "input": {"text": "Hello from Weavz!"},
        "workspaceId": "proj_abc123",
        "partialIds": ["partial_id_here"],
    },
)

Since the partial enforces channel, the caller only needs to provide text. The channel is locked to C01ABCDEF.

MCP Server Behavior

When a partial is assigned to an MCP server tool, enforced keys are automatically removed from the tool's input schema. This means the AI agent never sees or tries to set those fields — they are silently injected at execution time.

This is useful for:

Locking down channels — ensure a Slack bot only posts to a specific channel
Pre-filling API parameters — set a default model for OpenAI calls
Restricting scope — limit which GitHub repo an agent can interact with

Assign partials to MCP tools when adding or updating them:

bash

curl -X POST https://api.weavz.io/api/v1/mcp/servers/{serverId}/tools \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "integrationName": "slack",
    "actionName": "send_channel_message",
    "connectionId": "conn_abc",
    "partialIds": ["partial_id_here"]
  }'

typescript

await client.mcpServers.addTool(serverId, {
  integrationName: 'slack',
  actionName: 'send_channel_message',
  connectionId: 'conn_abc',
  partialIds: ['partial_id_here'],
})

python

client.mcp_servers.add_tool(
    server_id,
    integration_name="slack",
    action_name="send_channel_message",
    connection_id="conn_abc",
    partial_ids=["partial_id_here"],
)

typescript

await fetch(`https://api.weavz.io/api/v1/mcp/servers/${serverId}/tools`, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    integrationName: 'slack',
    actionName: 'send_channel_message',
    connectionId: 'conn_abc',
    partialIds: ['partial_id_here'],
  }),
})

python

httpx.post(
    f"https://api.weavz.io/api/v1/mcp/servers/{server_id}/tools",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "integrationName": "slack",
        "actionName": "send_channel_message",
        "connectionId": "conn_abc",
        "partialIds": ["partial_id_here"],
    },
)

Integration-Wide vs Action-Specific

Action-specific partials (actionName set) only apply to that action
Integration-wide partials (actionName null) apply to all actions for that integration

When both exist, action-specific partials take precedence over integration-wide ones.

Next Steps

Using Input Partials — step-by-step guide
Input Partials API Reference — full endpoint documentation
Actions — understand action execution
MCP Servers — configure MCP tools with partials