undo-redo-functionality for code blocks

.claude/commands/add-block.md

@@ -1,591 +0,0 @@
----
-description: Create a block configuration for a Sim Studio integration with proper subBlocks, conditions, and tool wiring
-argument-hint: <service-name>
----
-
-# Add Block Skill
-
-You are an expert at creating block configurations for Sim Studio. You understand the serializer, subBlock types, conditions, dependsOn, modes, and all UI patterns.
-
-## Your Task
-
-When the user asks you to create a block:
-1. Create the block file in `apps/sim/blocks/blocks/{service}.ts`
-2. Configure all subBlocks with proper types, conditions, and dependencies
-3. Wire up tools correctly
-
-## Block Configuration Structure
-
-```typescript
-import { {ServiceName}Icon } from '@/components/icons'
-import type { BlockConfig } from '@/blocks/types'
-import { AuthMode } from '@/blocks/types'
-
-export const {ServiceName}Block: BlockConfig = {
-  type: '{service}',                    // snake_case identifier
-  name: '{Service Name}',               // Human readable
-  description: 'Brief description',     // One sentence
-  longDescription: 'Detailed description for docs',
-  docsLink: 'https://docs.sim.ai/tools/{service}',
-  category: 'tools',                    // 'tools' | 'blocks' | 'triggers'
-  bgColor: '#HEXCOLOR',                 // Brand color
-  icon: {ServiceName}Icon,
-
-  // Auth mode
-  authMode: AuthMode.OAuth,             // or AuthMode.ApiKey
-
-  subBlocks: [
-    // Define all UI fields here
-  ],
-
-  tools: {
-    access: ['tool_id_1', 'tool_id_2'], // Array of tool IDs this block can use
-    config: {
-      tool: (params) => `{service}_${params.operation}`,  // Tool selector function
-      params: (params) => ({
-        // Transform subBlock values to tool params
-      }),
-    },
-  },
-
-  inputs: {
-    // Optional: define expected inputs from other blocks
-  },
-
-  outputs: {
-    // Define outputs available to downstream blocks
-  },
-}
-```
-
-## SubBlock Types Reference
-
-**Critical:** Every subblock `id` must be unique within the block. Duplicate IDs cause conflicts even with different conditions.
-
-### Text Inputs
-```typescript
-// Single-line input
-{ id: 'field', title: 'Label', type: 'short-input', placeholder: '...' }
-
-// Multi-line input
-{ id: 'field', title: 'Label', type: 'long-input', placeholder: '...', rows: 6 }
-
-// Password input
-{ id: 'apiKey', title: 'API Key', type: 'short-input', password: true }
-```
-
-### Selection Inputs
-```typescript
-// Dropdown (static options)
-{
-  id: 'operation',
-  title: 'Operation',
-  type: 'dropdown',
-  options: [
-    { label: 'Create', id: 'create' },
-    { label: 'Update', id: 'update' },
-  ],
-  value: () => 'create',  // Default value function
-}
-
-// Combobox (searchable dropdown)
-{
-  id: 'field',
-  title: 'Label',
-  type: 'combobox',
-  options: [...],
-  searchable: true,
-}
-```
-
-### Code/JSON Inputs
-```typescript
-{
-  id: 'code',
-  title: 'Code',
-  type: 'code',
-  language: 'javascript',  // 'javascript' | 'json' | 'python'
-  placeholder: '// Enter code...',
-}
-```
-
-### OAuth/Credentials
-```typescript
-{
-  id: 'credential',
-  title: 'Account',
-  type: 'oauth-input',
-  serviceId: '{service}',  // Must match OAuth provider
-  placeholder: 'Select account',
-  required: true,
-}
-```
-
-### Selectors (with dynamic options)
-```typescript
-// Channel selector (Slack, Discord, etc.)
-{
-  id: 'channel',
-  title: 'Channel',
-  type: 'channel-selector',
-  serviceId: '{service}',
-  placeholder: 'Select channel',
-  dependsOn: ['credential'],
-}
-
-// Project selector (Jira, etc.)
-{
-  id: 'project',
-  title: 'Project',
-  type: 'project-selector',
-  serviceId: '{service}',
-  dependsOn: ['credential'],
-}
-
-// File selector (Google Drive, etc.)
-{
-  id: 'file',
-  title: 'File',
-  type: 'file-selector',
-  serviceId: '{service}',
-  mimeType: 'application/pdf',
-  dependsOn: ['credential'],
-}
-
-// User selector
-{
-  id: 'user',
-  title: 'User',
-  type: 'user-selector',
-  serviceId: '{service}',
-  dependsOn: ['credential'],
-}
-```
-
-### Other Types
-```typescript
-// Switch/toggle
-{ id: 'enabled', type: 'switch' }
-
-// Slider
-{ id: 'temperature', title: 'Temperature', type: 'slider', min: 0, max: 2, step: 0.1 }
-
-// Table (key-value pairs)
-{ id: 'headers', title: 'Headers', type: 'table', columns: ['Key', 'Value'] }
-
-// File upload
-{
-  id: 'files',
-  title: 'Attachments',
-  type: 'file-upload',
-  multiple: true,
-  acceptedTypes: 'image/*,application/pdf',
-}
-```
-
-## Condition Syntax
-
-Controls when a field is shown based on other field values.
-
-### Simple Condition
-```typescript
-condition: { field: 'operation', value: 'create' }
-// Shows when operation === 'create'
-```
-
-### Multiple Values (OR)
-```typescript
-condition: { field: 'operation', value: ['create', 'update'] }
-// Shows when operation is 'create' OR 'update'
-```
-
-### Negation
-```typescript
-condition: { field: 'operation', value: 'delete', not: true }
-// Shows when operation !== 'delete'
-```
-
-### Compound (AND)
-```typescript
-condition: {
-  field: 'operation',
-  value: 'send',
-  and: {
-    field: 'type',
-    value: 'dm',
-    not: true,
-  }
-}
-// Shows when operation === 'send' AND type !== 'dm'
-```
-
-### Complex Example
-```typescript
-condition: {
-  field: 'operation',
-  value: ['list', 'search'],
-  not: true,
-  and: {
-    field: 'authMethod',
-    value: 'oauth',
-  }
-}
-// Shows when operation NOT in ['list', 'search'] AND authMethod === 'oauth'
-```
-
-## DependsOn Pattern
-
-Controls when a field is enabled and when its options are refetched.
-
-### Simple Array (all must be set)
-```typescript
-dependsOn: ['credential']
-// Enabled only when credential has a value
-// Options refetch when credential changes
-
-dependsOn: ['credential', 'projectId']
-// Enabled only when BOTH have values
-```
-
-### Complex (all + any)
-```typescript
-dependsOn: {
-  all: ['authMethod'],           // All must be set
-  any: ['credential', 'apiKey']  // At least one must be set
-}
-// Enabled when authMethod is set AND (credential OR apiKey is set)
-```
-
-## Required Pattern
-
-Can be boolean or condition-based.
-
-### Simple Boolean
-```typescript
-required: true
-required: false
-```
-
-### Conditional Required
-```typescript
-required: { field: 'operation', value: 'create' }
-// Required only when operation === 'create'
-
-required: { field: 'operation', value: ['create', 'update'] }
-// Required when operation is 'create' OR 'update'
-```
-
-## Mode Pattern (Basic vs Advanced)
-
-Controls which UI view shows the field.
-
-### Mode Options
-- `'basic'` - Only in basic view (default UI)
-- `'advanced'` - Only in advanced view
-- `'both'` - Both views (default if not specified)
-- `'trigger'` - Only in trigger configuration
-
-### canonicalParamId Pattern
-
-Maps multiple UI fields to a single serialized parameter:
-
-```typescript
-// Basic mode: Visual selector
-{
-  id: 'channel',
-  title: 'Channel',
-  type: 'channel-selector',
-  mode: 'basic',
-  canonicalParamId: 'channel',  // Both map to 'channel' param
-  dependsOn: ['credential'],
-}
-
-// Advanced mode: Manual input
-{
-  id: 'channelId',
-  title: 'Channel ID',
-  type: 'short-input',
-  mode: 'advanced',
-  canonicalParamId: 'channel',  // Both map to 'channel' param
-  placeholder: 'Enter channel ID manually',
-}
-```
-
-**How it works:**
-- In basic mode: `channel` selector value → `params.channel`
-- In advanced mode: `channelId` input value → `params.channel`
-- The serializer consolidates based on current mode
-
-**Critical constraints:**
-- `canonicalParamId` must NOT match any other subblock's `id` in the same block (causes conflicts)
-- `canonicalParamId` must be unique per block (only one basic/advanced pair per canonicalParamId)
-- ONLY use `canonicalParamId` to link basic/advanced mode alternatives for the same logical parameter
-- Do NOT use it for any other purpose
-
-## WandConfig Pattern
-
-Enables AI-assisted field generation.
-
-```typescript
-{
-  id: 'query',
-  title: 'Query',
-  type: 'code',
-  language: 'json',
-  wandConfig: {
-    enabled: true,
-    prompt: 'Generate a query based on the user request. Return ONLY the JSON.',
-    placeholder: 'Describe what you want to query...',
-    generationType: 'json-object',  // Optional: affects AI behavior
-    maintainHistory: true,          // Optional: keeps conversation context
-  },
-}
-```
-
-### Generation Types
-- `'javascript-function-body'` - JS code generation
-- `'json-object'` - Raw JSON (adds "no markdown" instruction)
-- `'json-schema'` - JSON Schema definitions
-- `'sql-query'` - SQL statements
-- `'timestamp'` - Adds current date/time context
-
-## Tools Configuration
-
-### Simple Tool Selector
-```typescript
-tools: {
-  access: ['service_create', 'service_read', 'service_update'],
-  config: {
-    tool: (params) => `service_${params.operation}`,
-  },
-}
-```
-
-### With Parameter Transformation
-```typescript
-tools: {
-  access: ['service_action'],
-  config: {
-    tool: (params) => 'service_action',
-    params: (params) => ({
-      id: params.resourceId,
-      data: typeof params.data === 'string' ? JSON.parse(params.data) : params.data,
-    }),
-  },
-}
-```
-
-### V2 Versioned Tool Selector
-```typescript
-import { createVersionedToolSelector } from '@/blocks/utils'
-
-tools: {
-  access: [
-    'service_create_v2',
-    'service_read_v2',
-    'service_update_v2',
-  ],
-  config: {
-    tool: createVersionedToolSelector({
-      baseToolSelector: (params) => `service_${params.operation}`,
-      suffix: '_v2',
-      fallbackToolId: 'service_create_v2',
-    }),
-  },
-}
-```
-
-## Outputs Definition
-
-**IMPORTANT:** Block outputs have a simpler schema than tool outputs. Block outputs do NOT support:
-- `optional: true` - This is only for tool outputs
-- `items` property - This is only for tool outputs with array types
-
-Block outputs only support:
-- `type` - The data type ('string', 'number', 'boolean', 'json', 'array')
-- `description` - Human readable description
-- Nested object structure (for complex types)
-
-```typescript
-outputs: {
-  // Simple outputs
-  id: { type: 'string', description: 'Resource ID' },
-  success: { type: 'boolean', description: 'Whether operation succeeded' },
-
-  // Use type: 'json' for complex objects or arrays (NOT type: 'array' with items)
-  items: { type: 'json', description: 'List of items' },
-  metadata: { type: 'json', description: 'Response metadata' },
-
-  // Nested outputs (for structured data)
-  user: {
-    id: { type: 'string', description: 'User ID' },
-    name: { type: 'string', description: 'User name' },
-    email: { type: 'string', description: 'User email' },
-  },
-}
-```
-
-## V2 Block Pattern
-
-When creating V2 blocks (alongside legacy V1):
-
-```typescript
-// V1 Block - mark as legacy
-export const ServiceBlock: BlockConfig = {
-  type: 'service',
-  name: 'Service (Legacy)',
-  hideFromToolbar: true,  // Hide from toolbar
-  // ... rest of config
-}
-
-// V2 Block - visible, uses V2 tools
-export const ServiceV2Block: BlockConfig = {
-  type: 'service_v2',
-  name: 'Service',              // Clean name
-  hideFromToolbar: false,       // Visible
-  subBlocks: ServiceBlock.subBlocks,  // Reuse UI
-  tools: {
-    access: ServiceBlock.tools?.access?.map(id => `${id}_v2`) || [],
-    config: {
-      tool: createVersionedToolSelector({
-        baseToolSelector: (params) => (ServiceBlock.tools?.config as any)?.tool(params),
-        suffix: '_v2',
-        fallbackToolId: 'service_default_v2',
-      }),
-      params: ServiceBlock.tools?.config?.params,
-    },
-  },
-  outputs: {
-    // Flat, API-aligned outputs (not wrapped in content/metadata)
-  },
-}
-```
-
-## Registering Blocks
-
-After creating the block, remind the user to:
-1. Import in `apps/sim/blocks/registry.ts`
-2. Add to the `registry` object (alphabetically):
-
-```typescript
-import { ServiceBlock } from '@/blocks/blocks/service'
-
-export const registry: Record<string, BlockConfig> = {
-  // ... existing blocks ...
-  service: ServiceBlock,
-}
-```
-
-## Complete Example
-
-```typescript
-import { ServiceIcon } from '@/components/icons'
-import type { BlockConfig } from '@/blocks/types'
-import { AuthMode } from '@/blocks/types'
-
-export const ServiceBlock: BlockConfig = {
-  type: 'service',
-  name: 'Service',
-  description: 'Integrate with Service API',
-  longDescription: 'Full description for documentation...',
-  docsLink: 'https://docs.sim.ai/tools/service',
-  category: 'tools',
-  bgColor: '#FF6B6B',
-  icon: ServiceIcon,
-  authMode: AuthMode.OAuth,
-
-  subBlocks: [
-    {
-      id: 'operation',
-      title: 'Operation',
-      type: 'dropdown',
-      options: [
-        { label: 'Create', id: 'create' },
-        { label: 'Read', id: 'read' },
-        { label: 'Update', id: 'update' },
-        { label: 'Delete', id: 'delete' },
-      ],
-      value: () => 'create',
-    },
-    {
-      id: 'credential',
-      title: 'Service Account',
-      type: 'oauth-input',
-      serviceId: 'service',
-      placeholder: 'Select account',
-      required: true,
-    },
-    {
-      id: 'resourceId',
-      title: 'Resource ID',
-      type: 'short-input',
-      placeholder: 'Enter resource ID',
-      condition: { field: 'operation', value: ['read', 'update', 'delete'] },
-      required: { field: 'operation', value: ['read', 'update', 'delete'] },
-    },
-    {
-      id: 'name',
-      title: 'Name',
-      type: 'short-input',
-      placeholder: 'Resource name',
-      condition: { field: 'operation', value: ['create', 'update'] },
-      required: { field: 'operation', value: 'create' },
-    },
-  ],
-
-  tools: {
-    access: ['service_create', 'service_read', 'service_update', 'service_delete'],
-    config: {
-      tool: (params) => `service_${params.operation}`,
-    },
-  },
-
-  outputs: {
-    id: { type: 'string', description: 'Resource ID' },
-    name: { type: 'string', description: 'Resource name' },
-    createdAt: { type: 'string', description: 'Creation timestamp' },
-  },
-}
-```
-
-## Connecting Blocks with Triggers
-
-If the service supports webhooks, connect the block to its triggers.
-
-```typescript
-import { getTrigger } from '@/triggers'
-
-export const ServiceBlock: BlockConfig = {
-  // ... basic config ...
-
-  triggers: {
-    enabled: true,
-    available: ['service_event_a', 'service_event_b', 'service_webhook'],
-  },
-
-  subBlocks: [
-    // Tool subBlocks first...
-    { id: 'operation', /* ... */ },
-
-    // Then spread trigger subBlocks
-    ...getTrigger('service_event_a').subBlocks,
-    ...getTrigger('service_event_b').subBlocks,
-    ...getTrigger('service_webhook').subBlocks,
-  ],
-}
-```
-
-See the `/add-trigger` skill for creating triggers.
-
-## Checklist Before Finishing
-
-- [ ] All subBlocks have `id`, `title` (except switch), and `type`
-- [ ] Conditions use correct syntax (field, value, not, and)
-- [ ] DependsOn set for fields that need other values
-- [ ] Required fields marked correctly (boolean or condition)
-- [ ] OAuth inputs have correct `serviceId`
-- [ ] Tools.access lists all tool IDs
-- [ ] Tools.config.tool returns correct tool ID
-- [ ] Outputs match tool outputs
-- [ ] Block registered in registry.ts
-- [ ] If triggers exist: `triggers` config set, trigger subBlocks spread

.claude/commands/add-integration.md

@@ -1,450 +0,0 @@
----
-description: Add a complete integration to Sim Studio (tools, block, icon, registration)
-argument-hint: <service-name> [api-docs-url]
----
-
-# Add Integration Skill
-
-You are an expert at adding complete integrations to Sim Studio. This skill orchestrates the full process of adding a new service integration.
-
-## Overview
-
-Adding an integration involves these steps in order:
-1. **Research** - Read the service's API documentation
-2. **Create Tools** - Build tool configurations for each API operation
-3. **Create Block** - Build the block UI configuration
-4. **Add Icon** - Add the service's brand icon
-5. **Create Triggers** (optional) - If the service supports webhooks
-6. **Register** - Register tools, block, and triggers in their registries
-7. **Generate Docs** - Run the docs generation script
-
-## Step 1: Research the API
-
-Before writing any code:
-1. Use Context7 to find official documentation: `mcp__plugin_context7_context7__resolve-library-id`
-2. Or use WebFetch to read API docs directly
-3. Identify:
-   - Authentication method (OAuth, API Key, both)
-   - Available operations (CRUD, search, etc.)
-   - Required vs optional parameters
-   - Response structures
-
-## Step 2: Create Tools
-
-### Directory Structure
-```
-apps/sim/tools/{service}/
-├── index.ts          # Barrel exports
-├── types.ts          # TypeScript interfaces
-├── {action1}.ts      # Tool for action 1
-├── {action2}.ts      # Tool for action 2
-└── ...
-```
-
-### Key Patterns
-
-**types.ts:**
-```typescript
-import type { ToolResponse } from '@/tools/types'
-
-export interface {Service}{Action}Params {
-  accessToken: string      // For OAuth services
-  // OR
-  apiKey: string          // For API key services
-
-  requiredParam: string
-  optionalParam?: string
-}
-
-export interface {Service}Response extends ToolResponse {
-  output: {
-    // Define output structure
-  }
-}
-```
-
-**Tool file pattern:**
-```typescript
-export const {service}{Action}Tool: ToolConfig<Params, Response> = {
-  id: '{service}_{action}',
-  name: '{Service} {Action}',
-  description: '...',
-  version: '1.0.0',
-
-  oauth: { required: true, provider: '{service}' },  // If OAuth
-
-  params: {
-    accessToken: { type: 'string', required: true, visibility: 'hidden', description: '...' },
-    // ... other params
-  },
-
-  request: { url, method, headers, body },
-
-  transformResponse: async (response) => {
-    const data = await response.json()
-    return {
-      success: true,
-      output: {
-        field: data.field ?? null,  // Always handle nullables
-      },
-    }
-  },
-
-  outputs: { /* ... */ },
-}
-```
-
-### Critical Rules
-- `visibility: 'hidden'` for OAuth tokens
-- `visibility: 'user-only'` for API keys and user credentials
-- `visibility: 'user-or-llm'` for operation parameters
-- Always use `?? null` for nullable API response fields
-- Always use `?? []` for optional array fields
-- Set `optional: true` for outputs that may not exist
-- Never output raw JSON dumps - extract meaningful fields
-
-## Step 3: Create Block
-
-### File Location
-`apps/sim/blocks/blocks/{service}.ts`
-
-### Block Structure
-```typescript
-import { {Service}Icon } from '@/components/icons'
-import type { BlockConfig } from '@/blocks/types'
-import { AuthMode } from '@/blocks/types'
-
-export const {Service}Block: BlockConfig = {
-  type: '{service}',
-  name: '{Service}',
-  description: '...',
-  longDescription: '...',
-  docsLink: 'https://docs.sim.ai/tools/{service}',
-  category: 'tools',
-  bgColor: '#HEXCOLOR',
-  icon: {Service}Icon,
-  authMode: AuthMode.OAuth,  // or AuthMode.ApiKey
-
-  subBlocks: [
-    // Operation dropdown
-    {
-      id: 'operation',
-      title: 'Operation',
-      type: 'dropdown',
-      options: [
-        { label: 'Operation 1', id: 'action1' },
-        { label: 'Operation 2', id: 'action2' },
-      ],
-      value: () => 'action1',
-    },
-    // Credential field
-    {
-      id: 'credential',
-      title: '{Service} Account',
-      type: 'oauth-input',
-      serviceId: '{service}',
-      required: true,
-    },
-    // Conditional fields per operation
-    // ...
-  ],
-
-  tools: {
-    access: ['{service}_action1', '{service}_action2'],
-    config: {
-      tool: (params) => `{service}_${params.operation}`,
-    },
-  },
-
-  outputs: { /* ... */ },
-}
-```
-
-### Key SubBlock Patterns
-
-**Condition-based visibility:**
-```typescript
-{
-  id: 'resourceId',
-  title: 'Resource ID',
-  type: 'short-input',
-  condition: { field: 'operation', value: ['read', 'update', 'delete'] },
-  required: { field: 'operation', value: ['read', 'update', 'delete'] },
-}
-```
-
-**DependsOn for cascading selectors:**
-```typescript
-{
-  id: 'project',
-  type: 'project-selector',
-  dependsOn: ['credential'],
-},
-{
-  id: 'issue',
-  type: 'file-selector',
-  dependsOn: ['credential', 'project'],
-}
-```
-
-**Basic/Advanced mode for dual UX:**
-```typescript
-// Basic: Visual selector
-{
-  id: 'channel',
-  type: 'channel-selector',
-  mode: 'basic',
-  canonicalParamId: 'channel',
-  dependsOn: ['credential'],
-},
-// Advanced: Manual input
-{
-  id: 'channelId',
-  type: 'short-input',
-  mode: 'advanced',
-  canonicalParamId: 'channel',
-}
-```
-
-**Critical:**
-- `canonicalParamId` must NOT match any other subblock's `id`, must be unique per block, and should only be used to link basic/advanced alternatives for the same parameter.
-- `mode` only controls UI visibility, NOT serialization. Without `canonicalParamId`, both basic and advanced field values would be sent.
-- Every subblock `id` must be unique within the block. Duplicate IDs cause conflicts even with different conditions.
-
-## Step 4: Add Icon
-
-### File Location
-`apps/sim/components/icons.tsx`
-
-### Pattern
-```typescript
-export function {Service}Icon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg
-      {...props}
-      viewBox="0 0 24 24"
-      fill="none"
-      xmlns="http://www.w3.org/2000/svg"
-    >
-      {/* SVG paths from brand assets */}
-    </svg>
-  )
-}
-```
-
-### Finding Icons
-1. Check the service's brand/press kit page
-2. Download SVG logo
-3. Convert to React component
-4. Ensure it accepts and spreads props
-
-## Step 5: Create Triggers (Optional)
-
-If the service supports webhooks, create triggers using the generic `buildTriggerSubBlocks` helper.
-
-### Directory Structure
-```
-apps/sim/triggers/{service}/
-├── index.ts      # Barrel exports
-├── utils.ts      # Trigger options, setup instructions, extra fields
-├── {event_a}.ts  # Primary trigger (includes dropdown)
-├── {event_b}.ts  # Secondary triggers (no dropdown)
-└── webhook.ts    # Generic webhook (optional)
-```
-
-### Key Pattern
-
-```typescript
-import { buildTriggerSubBlocks } from '@/triggers'
-import { {service}TriggerOptions, {service}SetupInstructions, build{Service}ExtraFields } from './utils'
-
-// Primary trigger - includeDropdown: true
-export const {service}EventATrigger: TriggerConfig = {
-  id: '{service}_event_a',
-  subBlocks: buildTriggerSubBlocks({
-    triggerId: '{service}_event_a',
-    triggerOptions: {service}TriggerOptions,
-    includeDropdown: true,  // Only for primary trigger!
-    setupInstructions: {service}SetupInstructions('Event A'),
-    extraFields: build{Service}ExtraFields('{service}_event_a'),
-  }),
-  // ...
-}
-
-// Secondary triggers - no dropdown
-export const {service}EventBTrigger: TriggerConfig = {
-  id: '{service}_event_b',
-  subBlocks: buildTriggerSubBlocks({
-    triggerId: '{service}_event_b',
-    triggerOptions: {service}TriggerOptions,
-    // No includeDropdown!
-    setupInstructions: {service}SetupInstructions('Event B'),
-    extraFields: build{Service}ExtraFields('{service}_event_b'),
-  }),
-  // ...
-}
-```
-
-### Connect to Block
-```typescript
-import { getTrigger } from '@/triggers'
-
-export const {Service}Block: BlockConfig = {
-  triggers: {
-    enabled: true,
-    available: ['{service}_event_a', '{service}_event_b'],
-  },
-  subBlocks: [
-    // Tool fields...
-    ...getTrigger('{service}_event_a').subBlocks,
-    ...getTrigger('{service}_event_b').subBlocks,
-  ],
-}
-```
-
-See `/add-trigger` skill for complete documentation.
-
-## Step 6: Register Everything
-
-### Tools Registry (`apps/sim/tools/registry.ts`)
-
-```typescript
-// Add import (alphabetically)
-import {
-  {service}Action1Tool,
-  {service}Action2Tool,
-} from '@/tools/{service}'
-
-// Add to tools object (alphabetically)
-export const tools: Record<string, ToolConfig> = {
-  // ... existing tools ...
-  {service}_action1: {service}Action1Tool,
-  {service}_action2: {service}Action2Tool,
-}
-```
-
-### Block Registry (`apps/sim/blocks/registry.ts`)
-
-```typescript
-// Add import (alphabetically)
-import { {Service}Block } from '@/blocks/blocks/{service}'
-
-// Add to registry (alphabetically)
-export const registry: Record<string, BlockConfig> = {
-  // ... existing blocks ...
-  {service}: {Service}Block,
-}
-```
-
-### Trigger Registry (`apps/sim/triggers/registry.ts`) - If triggers exist
-
-```typescript
-// Add import (alphabetically)
-import {
-  {service}EventATrigger,
-  {service}EventBTrigger,
-  {service}WebhookTrigger,
-} from '@/triggers/{service}'
-
-// Add to TRIGGER_REGISTRY (alphabetically)
-export const TRIGGER_REGISTRY: TriggerRegistry = {
-  // ... existing triggers ...
-  {service}_event_a: {service}EventATrigger,
-  {service}_event_b: {service}EventBTrigger,
-  {service}_webhook: {service}WebhookTrigger,
-}
-```
-
-## Step 7: Generate Docs
-
-Run the documentation generator:
-```bash
-bun run scripts/generate-docs.ts
-```
-
-This creates `apps/docs/content/docs/en/tools/{service}.mdx`
-
-## V2 Integration Pattern
-
-If creating V2 versions (API-aligned outputs):
-
-1. **V2 Tools** - Add `_v2` suffix, version `2.0.0`, flat outputs
-2. **V2 Block** - Add `_v2` type, use `createVersionedToolSelector`
-3. **V1 Block** - Add `(Legacy)` to name, set `hideFromToolbar: true`
-4. **Registry** - Register both versions
-
-```typescript
-// In registry
-{service}: {Service}Block,        // V1 (legacy, hidden)
-{service}_v2: {Service}V2Block,   // V2 (visible)
-```
-
-## Complete Checklist
-
-### Tools
-- [ ] Created `tools/{service}/` directory
-- [ ] Created `types.ts` with all interfaces
-- [ ] Created tool file for each operation
-- [ ] All params have correct visibility
-- [ ] All nullable fields use `?? null`
-- [ ] All optional outputs have `optional: true`
-- [ ] Created `index.ts` barrel export
-- [ ] Registered all tools in `tools/registry.ts`
-
-### Block
-- [ ] Created `blocks/blocks/{service}.ts`
-- [ ] Defined operation dropdown with all operations
-- [ ] Added credential field (oauth-input or short-input)
-- [ ] Added conditional fields per operation
-- [ ] Set up dependsOn for cascading selectors
-- [ ] Configured tools.access with all tool IDs
-- [ ] Configured tools.config.tool selector
-- [ ] Defined outputs matching tool outputs
-- [ ] Registered block in `blocks/registry.ts`
-- [ ] If triggers: set `triggers.enabled` and `triggers.available`
-- [ ] If triggers: spread trigger subBlocks with `getTrigger()`
-
-### Icon
-- [ ] Added icon to `components/icons.tsx`
-- [ ] Icon spreads props correctly
-
-### Triggers (if service supports webhooks)
-- [ ] Created `triggers/{service}/` directory
-- [ ] Created `utils.ts` with options, instructions, and extra fields helpers
-- [ ] Primary trigger uses `includeDropdown: true`
-- [ ] Secondary triggers do NOT have `includeDropdown`
-- [ ] All triggers use `buildTriggerSubBlocks` helper
-- [ ] Created `index.ts` barrel export
-- [ ] Registered all triggers in `triggers/registry.ts`
-
-### Docs
-- [ ] Ran `bun run scripts/generate-docs.ts`
-- [ ] Verified docs file created
-
-## Example Command
-
-When the user asks to add an integration:
-
-```
-User: Add a Stripe integration
-
-You: I'll add the Stripe integration. Let me:
-
-1. First, research the Stripe API using Context7
-2. Create the tools for key operations (payments, subscriptions, etc.)
-3. Create the block with operation dropdown
-4. Add the Stripe icon
-5. Register everything
-6. Generate docs
-
-[Proceed with implementation...]
-```
-
-## Common Gotchas
-
-1. **OAuth serviceId must match** - The `serviceId` in oauth-input must match the OAuth provider configuration
-2. **Tool IDs are snake_case** - `stripe_create_payment`, not `stripeCreatePayment`
-3. **Block type is snake_case** - `type: 'stripe'`, not `type: 'Stripe'`
-4. **Alphabetical ordering** - Keep imports and registry entries alphabetically sorted
-5. **Required can be conditional** - Use `required: { field: 'op', value: 'create' }` instead of always true
-6. **DependsOn clears options** - When a dependency changes, selector options are refetched

.claude/commands/add-tools.md

@@ -1,284 +0,0 @@
----
-description: Create tool configurations for a Sim Studio integration by reading API docs
-argument-hint: <service-name> [api-docs-url]
----
-
-# Add Tools Skill
-
-You are an expert at creating tool configurations for Sim Studio integrations. Your job is to read API documentation and create properly structured tool files.
-
-## Your Task
-
-When the user asks you to create tools for a service:
-1. Use Context7 or WebFetch to read the service's API documentation
-2. Create the tools directory structure
-3. Generate properly typed tool configurations
-
-## Directory Structure
-
-Create files in `apps/sim/tools/{service}/`:
-```
-tools/{service}/
-├── index.ts      # Barrel export
-├── types.ts      # Parameter & response types
-└── {action}.ts   # Individual tool files (one per operation)
-```
-
-## Tool Configuration Structure
-
-Every tool MUST follow this exact structure:
-
-```typescript
-import type { {ServiceName}{Action}Params } from '@/tools/{service}/types'
-import type { ToolConfig } from '@/tools/types'
-
-interface {ServiceName}{Action}Response {
-  success: boolean
-  output: {
-    // Define output structure here
-  }
-}
-
-export const {serviceName}{Action}Tool: ToolConfig<
-  {ServiceName}{Action}Params,
-  {ServiceName}{Action}Response
-> = {
-  id: '{service}_{action}',           // snake_case, matches tool name
-  name: '{Service} {Action}',         // Human readable
-  description: 'Brief description',   // One sentence
-  version: '1.0.0',
-
-  // OAuth config (if service uses OAuth)
-  oauth: {
-    required: true,
-    provider: '{service}',            // Must match OAuth provider ID
-  },
-
-  params: {
-    // Hidden params (system-injected)
-    accessToken: {
-      type: 'string',
-      required: true,
-      visibility: 'hidden',
-      description: 'OAuth access token',
-    },
-    // User-only params (credentials, IDs user must provide)
-    someId: {
-      type: 'string',
-      required: true,
-      visibility: 'user-only',
-      description: 'The ID of the resource',
-    },
-    // User-or-LLM params (can be provided by user OR computed by LLM)
-    query: {
-      type: 'string',
-      required: false,                // Use false for optional
-      visibility: 'user-or-llm',
-      description: 'Search query',
-    },
-  },
-
-  request: {
-    url: (params) => `https://api.service.com/v1/resource/${params.id}`,
-    method: 'POST',
-    headers: (params) => ({
-      Authorization: `Bearer ${params.accessToken}`,
-      'Content-Type': 'application/json',
-    }),
-    body: (params) => ({
-      // Request body - only for POST/PUT/PATCH
-      // Trim ID fields to prevent copy-paste whitespace errors:
-      // userId: params.userId?.trim(),
-    }),
-  },
-
-  transformResponse: async (response: Response) => {
-    const data = await response.json()
-    return {
-      success: true,
-      output: {
-        // Map API response to output
-        // Use ?? null for nullable fields
-        // Use ?? [] for optional arrays
-      },
-    }
-  },
-
-  outputs: {
-    // Define each output field
-  },
-}
-```
-
-## Critical Rules for Parameters
-
-### Visibility Options
-- `'hidden'` - System-injected (OAuth tokens, internal params). User never sees.
-- `'user-only'` - User must provide (credentials, account-specific IDs)
-- `'user-or-llm'` - User provides OR LLM can compute (search queries, content, filters)
-
-### Parameter Types
-- `'string'` - Text values
-- `'number'` - Numeric values
-- `'boolean'` - True/false
-- `'json'` - Complex objects (NOT 'object', use 'json')
-- `'file'` - Single file
-- `'file[]'` - Multiple files
-
-### Required vs Optional
-- Always explicitly set `required: true` or `required: false`
-- Optional params should have `required: false`
-
-## Critical Rules for Outputs
-
-### Output Types
-- `'string'`, `'number'`, `'boolean'` - Primitives
-- `'json'` - Complex objects (use this, NOT 'object')
-- `'array'` - Arrays with `items` property
-- `'object'` - Objects with `properties` property
-
-### Optional Outputs
-Add `optional: true` for fields that may not exist in the response:
-```typescript
-closedAt: {
-  type: 'string',
-  description: 'When the issue was closed',
-  optional: true,
-},
-```
-
-### Nested Properties
-For complex outputs, define nested structure:
-```typescript
-metadata: {
-  type: 'json',
-  description: 'Response metadata',
-  properties: {
-    id: { type: 'string', description: 'Unique ID' },
-    status: { type: 'string', description: 'Current status' },
-    count: { type: 'number', description: 'Total count' },
-  },
-},
-
-items: {
-  type: 'array',
-  description: 'List of items',
-  items: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Item ID' },
-      name: { type: 'string', description: 'Item name' },
-    },
-  },
-},
-```
-
-## Critical Rules for transformResponse
-
-### Handle Nullable Fields
-ALWAYS use `?? null` for fields that may be undefined:
-```typescript
-transformResponse: async (response: Response) => {
-  const data = await response.json()
-  return {
-    success: true,
-    output: {
-      id: data.id,
-      title: data.title,
-      body: data.body ?? null,           // May be undefined
-      assignee: data.assignee ?? null,   // May be undefined
-      labels: data.labels ?? [],         // Default to empty array
-      closedAt: data.closed_at ?? null,  // May be undefined
-    },
-  }
-}
-```
-
-### Never Output Raw JSON Dumps
-DON'T do this:
-```typescript
-output: {
-  data: data,  // BAD - raw JSON dump
-}
-```
-
-DO this instead - extract meaningful fields:
-```typescript
-output: {
-  id: data.id,
-  name: data.name,
-  status: data.status,
-  metadata: {
-    createdAt: data.created_at,
-    updatedAt: data.updated_at,
-  },
-}
-```
-
-## Types File Pattern
-
-Create `types.ts` with interfaces for all params and responses:
-
-```typescript
-import type { ToolResponse } from '@/tools/types'
-
-// Parameter interfaces
-export interface {Service}{Action}Params {
-  accessToken: string
-  requiredField: string
-  optionalField?: string
-}
-
-// Response interfaces (extend ToolResponse)
-export interface {Service}{Action}Response extends ToolResponse {
-  output: {
-    field1: string
-    field2: number
-    optionalField?: string | null
-  }
-}
-```
-
-## Index.ts Barrel Export Pattern
-
-```typescript
-// Export all tools
-export { serviceTool1 } from './{action1}'
-export { serviceTool2 } from './{action2}'
-
-// Export types
-export * from './types'
-```
-
-## Registering Tools
-
-After creating tools, remind the user to:
-1. Import tools in `apps/sim/tools/registry.ts`
-2. Add to the `tools` object with snake_case keys:
-```typescript
-import { serviceActionTool } from '@/tools/{service}'
-
-export const tools = {
-  // ... existing tools ...
-  {service}_{action}: serviceActionTool,
-}
-```
-
-## V2 Tool Pattern
-
-If creating V2 tools (API-aligned outputs), use `_v2` suffix:
-- Tool ID: `{service}_{action}_v2`
-- Variable name: `{action}V2Tool`
-- Version: `'2.0.0'`
-- Outputs: Flat, API-aligned (no content/metadata wrapper)
-
-## Checklist Before Finishing
-
-- [ ] All params have explicit `required: true` or `required: false`
-- [ ] All params have appropriate `visibility`
-- [ ] All nullable response fields use `?? null`
-- [ ] All optional outputs have `optional: true`
-- [ ] No raw JSON dumps in outputs
-- [ ] Types file has all interfaces
-- [ ] Index.ts exports all tools
-- [ ] Tool IDs use snake_case

.claude/commands/add-trigger.md

@@ -1,656 +0,0 @@
----
-description: Create webhook triggers for a Sim Studio integration using the generic trigger builder
-argument-hint: <service-name>
----
-
-# Add Trigger Skill
-
-You are an expert at creating webhook triggers for Sim Studio. You understand the trigger system, the generic `buildTriggerSubBlocks` helper, and how triggers connect to blocks.
-
-## Your Task
-
-When the user asks you to create triggers for a service:
-1. Research what webhook events the service supports
-2. Create the trigger files using the generic builder
-3. Register triggers and connect them to the block
-
-## Directory Structure
-
-```
-apps/sim/triggers/{service}/
-├── index.ts              # Barrel exports
-├── utils.ts              # Service-specific helpers (trigger options, setup instructions, extra fields)
-├── {event_a}.ts          # Primary trigger (includes dropdown)
-├── {event_b}.ts          # Secondary trigger (no dropdown)
-├── {event_c}.ts          # Secondary trigger (no dropdown)
-└── webhook.ts            # Generic webhook trigger (optional, for "all events")
-```
-
-## Step 1: Create utils.ts
-
-This file contains service-specific helpers used by all triggers.
-
-```typescript
-import type { SubBlockConfig } from '@/blocks/types'
-import type { TriggerOutput } from '@/triggers/types'
-
-/**
- * Dropdown options for the trigger type selector.
- * These appear in the primary trigger's dropdown.
- */
-export const {service}TriggerOptions = [
-  { label: 'Event A', id: '{service}_event_a' },
-  { label: 'Event B', id: '{service}_event_b' },
-  { label: 'Event C', id: '{service}_event_c' },
-  { label: 'Generic Webhook (All Events)', id: '{service}_webhook' },
-]
-
-/**
- * Generates HTML setup instructions for the trigger.
- * Displayed to users to help them configure webhooks in the external service.
- */
-export function {service}SetupInstructions(eventType: string): string {
-  const instructions = [
-    'Copy the <strong>Webhook URL</strong> above',
-    'Go to <strong>{Service} Settings > Webhooks</strong>',
-    'Click <strong>Add Webhook</strong>',
-    'Paste the webhook URL',
-    `Select the <strong>${eventType}</strong> event type`,
-    'Save the webhook configuration',
-    'Click "Save" above to activate your trigger',
-  ]
-
-  return instructions
-    .map((instruction, index) =>
-      `<div class="mb-3"><strong>${index + 1}.</strong> ${instruction}</div>`
-    )
-    .join('')
-}
-
-/**
- * Service-specific extra fields to add to triggers.
- * These are inserted between webhookUrl and triggerSave.
- */
-export function build{Service}ExtraFields(triggerId: string): SubBlockConfig[] {
-  return [
-    {
-      id: 'projectId',
-      title: 'Project ID (Optional)',
-      type: 'short-input',
-      placeholder: 'Leave empty for all projects',
-      description: 'Optionally filter to a specific project',
-      mode: 'trigger',
-      condition: { field: 'selectedTriggerId', value: triggerId },
-    },
-  ]
-}
-
-/**
- * Build outputs for this trigger type.
- * Outputs define what data is available to downstream blocks.
- */
-export function build{Service}Outputs(): Record<string, TriggerOutput> {
-  return {
-    eventType: { type: 'string', description: 'The type of event that triggered this workflow' },
-    resourceId: { type: 'string', description: 'ID of the affected resource' },
-    timestamp: { type: 'string', description: 'When the event occurred (ISO 8601)' },
-    // Nested outputs for complex data
-    resource: {
-      id: { type: 'string', description: 'Resource ID' },
-      name: { type: 'string', description: 'Resource name' },
-      status: { type: 'string', description: 'Current status' },
-    },
-    webhook: { type: 'json', description: 'Full webhook payload' },
-  }
-}
-```
-
-## Step 2: Create the Primary Trigger
-
-The **primary trigger** is the first one listed. It MUST include `includeDropdown: true` so users can switch between trigger types.
-
-```typescript
-import { {Service}Icon } from '@/components/icons'
-import { buildTriggerSubBlocks } from '@/triggers'
-import {
-  build{Service}ExtraFields,
-  build{Service}Outputs,
-  {service}SetupInstructions,
-  {service}TriggerOptions,
-} from '@/triggers/{service}/utils'
-import type { TriggerConfig } from '@/triggers/types'
-
-/**
- * {Service} Event A Trigger
- *
- * This is the PRIMARY trigger - it includes the dropdown for selecting trigger type.
- */
-export const {service}EventATrigger: TriggerConfig = {
-  id: '{service}_event_a',
-  name: '{Service} Event A',
-  provider: '{service}',
-  description: 'Trigger workflow when Event A occurs',
-  version: '1.0.0',
-  icon: {Service}Icon,
-
-  subBlocks: buildTriggerSubBlocks({
-    triggerId: '{service}_event_a',
-    triggerOptions: {service}TriggerOptions,
-    includeDropdown: true,  // PRIMARY TRIGGER - includes dropdown
-    setupInstructions: {service}SetupInstructions('Event A'),
-    extraFields: build{Service}ExtraFields('{service}_event_a'),
-  }),
-
-  outputs: build{Service}Outputs(),
-
-  webhook: {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  },
-}
-```
-
-## Step 3: Create Secondary Triggers
-
-Secondary triggers do NOT include the dropdown (it's already in the primary trigger).
-
-```typescript
-import { {Service}Icon } from '@/components/icons'
-import { buildTriggerSubBlocks } from '@/triggers'
-import {
-  build{Service}ExtraFields,
-  build{Service}Outputs,
-  {service}SetupInstructions,
-  {service}TriggerOptions,
-} from '@/triggers/{service}/utils'
-import type { TriggerConfig } from '@/triggers/types'
-
-/**
- * {Service} Event B Trigger
- */
-export const {service}EventBTrigger: TriggerConfig = {
-  id: '{service}_event_b',
-  name: '{Service} Event B',
-  provider: '{service}',
-  description: 'Trigger workflow when Event B occurs',
-  version: '1.0.0',
-  icon: {Service}Icon,
-
-  subBlocks: buildTriggerSubBlocks({
-    triggerId: '{service}_event_b',
-    triggerOptions: {service}TriggerOptions,
-    // NO includeDropdown - secondary trigger
-    setupInstructions: {service}SetupInstructions('Event B'),
-    extraFields: build{Service}ExtraFields('{service}_event_b'),
-  }),
-
-  outputs: build{Service}Outputs(),
-
-  webhook: {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  },
-}
-```
-
-## Step 4: Create index.ts Barrel Export
-
-```typescript
-export { {service}EventATrigger } from './event_a'
-export { {service}EventBTrigger } from './event_b'
-export { {service}EventCTrigger } from './event_c'
-export { {service}WebhookTrigger } from './webhook'
-```
-
-## Step 5: Register Triggers
-
-### Trigger Registry (`apps/sim/triggers/registry.ts`)
-
-```typescript
-// Add import
-import {
-  {service}EventATrigger,
-  {service}EventBTrigger,
-  {service}EventCTrigger,
-  {service}WebhookTrigger,
-} from '@/triggers/{service}'
-
-// Add to TRIGGER_REGISTRY
-export const TRIGGER_REGISTRY: TriggerRegistry = {
-  // ... existing triggers ...
-  {service}_event_a: {service}EventATrigger,
-  {service}_event_b: {service}EventBTrigger,
-  {service}_event_c: {service}EventCTrigger,
-  {service}_webhook: {service}WebhookTrigger,
-}
-```
-
-## Step 6: Connect Triggers to Block
-
-In the block file (`apps/sim/blocks/blocks/{service}.ts`):
-
-```typescript
-import { {Service}Icon } from '@/components/icons'
-import { getTrigger } from '@/triggers'
-import type { BlockConfig } from '@/blocks/types'
-
-export const {Service}Block: BlockConfig = {
-  type: '{service}',
-  name: '{Service}',
-  // ... other config ...
-
-  // Enable triggers and list available trigger IDs
-  triggers: {
-    enabled: true,
-    available: [
-      '{service}_event_a',
-      '{service}_event_b',
-      '{service}_event_c',
-      '{service}_webhook',
-    ],
-  },
-
-  subBlocks: [
-    // Regular tool subBlocks first
-    { id: 'operation', /* ... */ },
-    { id: 'credential', /* ... */ },
-    // ... other tool fields ...
-
-    // Then spread ALL trigger subBlocks
-    ...getTrigger('{service}_event_a').subBlocks,
-    ...getTrigger('{service}_event_b').subBlocks,
-    ...getTrigger('{service}_event_c').subBlocks,
-    ...getTrigger('{service}_webhook').subBlocks,
-  ],
-
-  // ... tools config ...
-}
-```
-
-## Automatic Webhook Registration (Preferred)
-
-If the service's API supports programmatic webhook creation, implement automatic webhook registration instead of requiring users to manually configure webhooks. This provides a much better user experience.
-
-### When to Use Automatic Registration
-
-Check the service's API documentation for endpoints like:
-- `POST /webhooks` or `POST /hooks` - Create webhook
-- `DELETE /webhooks/{id}` - Delete webhook
-
-Services that support this pattern include: Grain, Lemlist, Calendly, Airtable, Webflow, Typeform, etc.
-
-### Implementation Steps
-
-#### 1. Add API Key to Extra Fields
-
-Update your `build{Service}ExtraFields` function to include an API key field:
-
-```typescript
-export function build{Service}ExtraFields(triggerId: string): SubBlockConfig[] {
-  return [
-    {
-      id: 'apiKey',
-      title: 'API Key',
-      type: 'short-input',
-      placeholder: 'Enter your {Service} API key',
-      description: 'Required to create the webhook in {Service}.',
-      password: true,
-      required: true,
-      mode: 'trigger',
-      condition: { field: 'selectedTriggerId', value: triggerId },
-    },
-    // Other optional fields (e.g., campaign filter, project filter)
-    {
-      id: 'projectId',
-      title: 'Project ID (Optional)',
-      type: 'short-input',
-      placeholder: 'Leave empty for all projects',
-      mode: 'trigger',
-      condition: { field: 'selectedTriggerId', value: triggerId },
-    },
-  ]
-}
-```
-
-#### 2. Update Setup Instructions for Automatic Creation
-
-Change instructions to indicate automatic webhook creation:
-
-```typescript
-export function {service}SetupInstructions(eventType: string): string {
-  const instructions = [
-    'Enter your {Service} API Key above.',
-    'You can find your API key in {Service} at <strong>Settings > API</strong>.',
-    `Click <strong>"Save Configuration"</strong> to automatically create the webhook in {Service} for <strong>${eventType}</strong> events.`,
-    'The webhook will be automatically deleted when you remove this trigger.',
-  ]
-
-  return instructions
-    .map((instruction, index) =>
-      `<div class="mb-3"><strong>${index + 1}.</strong> ${instruction}</div>`
-    )
-    .join('')
-}
-```
-
-#### 3. Add Webhook Creation to API Route
-
-In `apps/sim/app/api/webhooks/route.ts`, add provider-specific logic after the database save:
-
-```typescript
-// --- {Service} specific logic ---
-if (savedWebhook && provider === '{service}') {
-  logger.info(`[${requestId}] {Service} provider detected. Creating webhook subscription.`)
-  try {
-    const result = await create{Service}WebhookSubscription(
-      {
-        id: savedWebhook.id,
-        path: savedWebhook.path,
-        providerConfig: savedWebhook.providerConfig,
-      },
-      requestId
-    )
-
-    if (result) {
-      // Update the webhook record with the external webhook ID
-      const updatedConfig = {
-        ...(savedWebhook.providerConfig as Record<string, any>),
-        externalId: result.id,
-      }
-      await db
-        .update(webhook)
-        .set({
-          providerConfig: updatedConfig,
-          updatedAt: new Date(),
-        })
-        .where(eq(webhook.id, savedWebhook.id))
-
-      savedWebhook.providerConfig = updatedConfig
-      logger.info(`[${requestId}] Successfully created {Service} webhook`, {
-        externalHookId: result.id,
-        webhookId: savedWebhook.id,
-      })
-    }
-  } catch (err) {
-    logger.error(
-      `[${requestId}] Error creating {Service} webhook subscription, rolling back webhook`,
-      err
-    )
-    await db.delete(webhook).where(eq(webhook.id, savedWebhook.id))
-    return NextResponse.json(
-      {
-        error: 'Failed to create webhook in {Service}',
-        details: err instanceof Error ? err.message : 'Unknown error',
-      },
-      { status: 500 }
-    )
-  }
-}
-// --- End {Service} specific logic ---
-```
-
-Then add the helper function at the end of the file:
-
-```typescript
-async function create{Service}WebhookSubscription(
-  webhookData: any,
-  requestId: string
-): Promise<{ id: string } | undefined> {
-  try {
-    const { path, providerConfig } = webhookData
-    const { apiKey, triggerId, projectId } = providerConfig || {}
-
-    if (!apiKey) {
-      throw new Error('{Service} API Key is required.')
-    }
-
-    // Map trigger IDs to service event types
-    const eventTypeMap: Record<string, string | undefined> = {
-      {service}_event_a: 'eventA',
-      {service}_event_b: 'eventB',
-      {service}_webhook: undefined, // Generic - no filter
-    }
-
-    const eventType = eventTypeMap[triggerId]
-    const notificationUrl = `${getBaseUrl()}/api/webhooks/trigger/${path}`
-
-    const requestBody: Record<string, any> = {
-      url: notificationUrl,
-    }
-
-    if (eventType) {
-      requestBody.eventType = eventType
-    }
-
-    if (projectId) {
-      requestBody.projectId = projectId
-    }
-
-    const response = await fetch('https://api.{service}.com/webhooks', {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(requestBody),
-    })
-
-    const responseBody = await response.json()
-
-    if (!response.ok) {
-      const errorMessage = responseBody.message || 'Unknown API error'
-      let userFriendlyMessage = 'Failed to create webhook in {Service}'
-
-      if (response.status === 401) {
-        userFriendlyMessage = 'Invalid API Key. Please verify and try again.'
-      } else if (errorMessage) {
-        userFriendlyMessage = `{Service} error: ${errorMessage}`
-      }
-
-      throw new Error(userFriendlyMessage)
-    }
-
-    return { id: responseBody.id }
-  } catch (error: any) {
-    logger.error(`Exception during {Service} webhook creation`, { error: error.message })
-    throw error
-  }
-}
-```
-
-#### 4. Add Webhook Deletion to Provider Subscriptions
-
-In `apps/sim/lib/webhooks/provider-subscriptions.ts`:
-
-1. Add a logger:
-```typescript
-const {service}Logger = createLogger('{Service}Webhook')
-```
-
-2. Add the delete function:
-```typescript
-export async function delete{Service}Webhook(webhook: any, requestId: string): Promise<void> {
-  try {
-    const config = getProviderConfig(webhook)
-    const apiKey = config.apiKey as string | undefined
-    const externalId = config.externalId as string | undefined
-
-    if (!apiKey || !externalId) {
-      {service}Logger.warn(`[${requestId}] Missing apiKey or externalId, skipping cleanup`)
-      return
-    }
-
-    const response = await fetch(`https://api.{service}.com/webhooks/${externalId}`, {
-      method: 'DELETE',
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    })
-
-    if (!response.ok && response.status !== 404) {
-      {service}Logger.warn(`[${requestId}] Failed to delete webhook (non-fatal): ${response.status}`)
-    } else {
-      {service}Logger.info(`[${requestId}] Successfully deleted webhook ${externalId}`)
-    }
-  } catch (error) {
-    {service}Logger.warn(`[${requestId}] Error deleting webhook (non-fatal)`, error)
-  }
-}
-```
-
-3. Add to `cleanupExternalWebhook`:
-```typescript
-export async function cleanupExternalWebhook(...): Promise<void> {
-  // ... existing providers ...
-  } else if (webhook.provider === '{service}') {
-    await delete{Service}Webhook(webhook, requestId)
-  }
-}
-```
-
-### Key Points for Automatic Registration
-
-- **API Key visibility**: Always use `password: true` for API key fields
-- **Error handling**: Roll back the database webhook if external creation fails
-- **External ID storage**: Save the external webhook ID in `providerConfig.externalId`
-- **Graceful cleanup**: Don't fail webhook deletion if cleanup fails (use non-fatal logging)
-- **User-friendly errors**: Map HTTP status codes to helpful error messages
-
-## The buildTriggerSubBlocks Helper
-
-This is the generic helper from `@/triggers` that creates consistent trigger subBlocks.
-
-### Function Signature
-
-```typescript
-interface BuildTriggerSubBlocksOptions {
-  triggerId: string                              // e.g., 'service_event_a'
-  triggerOptions: Array<{ label: string; id: string }>  // Dropdown options
-  includeDropdown?: boolean                      // true only for primary trigger
-  setupInstructions: string                      // HTML instructions
-  extraFields?: SubBlockConfig[]                 // Service-specific fields
-  webhookPlaceholder?: string                    // Custom placeholder text
-}
-
-function buildTriggerSubBlocks(options: BuildTriggerSubBlocksOptions): SubBlockConfig[]
-```
-
-### What It Creates
-
-The helper creates this structure:
-1. **Dropdown** (only if `includeDropdown: true`) - Trigger type selector
-2. **Webhook URL** - Read-only field with copy button
-3. **Extra Fields** - Your service-specific fields (filters, options, etc.)
-4. **Save Button** - Activates the trigger
-5. **Instructions** - Setup guide for users
-
-All fields automatically have:
-- `mode: 'trigger'` - Only shown in trigger mode
-- `condition: { field: 'selectedTriggerId', value: triggerId }` - Only shown when this trigger is selected
-
-## Trigger Outputs
-
-Trigger outputs use the same schema as block outputs (NOT tool outputs).
-
-**Supported:**
-- `type` and `description` for simple fields
-- Nested object structure for complex data
-
-**NOT Supported:**
-- `optional: true` (tool outputs only)
-- `items` property (tool outputs only)
-
-```typescript
-export function buildOutputs(): Record<string, TriggerOutput> {
-  return {
-    // Simple fields
-    eventType: { type: 'string', description: 'Event type' },
-    timestamp: { type: 'string', description: 'When it occurred' },
-
-    // Complex data - use type: 'json'
-    payload: { type: 'json', description: 'Full event payload' },
-
-    // Nested structure
-    resource: {
-      id: { type: 'string', description: 'Resource ID' },
-      name: { type: 'string', description: 'Resource name' },
-    },
-  }
-}
-```
-
-## Generic Webhook Trigger Pattern
-
-For services with many event types, create a generic webhook that accepts all events:
-
-```typescript
-export const {service}WebhookTrigger: TriggerConfig = {
-  id: '{service}_webhook',
-  name: '{Service} Webhook (All Events)',
-  // ...
-
-  subBlocks: buildTriggerSubBlocks({
-    triggerId: '{service}_webhook',
-    triggerOptions: {service}TriggerOptions,
-    setupInstructions: {service}SetupInstructions('All Events'),
-    extraFields: [
-      // Event type filter (optional)
-      {
-        id: 'eventTypes',
-        title: 'Event Types',
-        type: 'dropdown',
-        multiSelect: true,
-        options: [
-          { label: 'Event A', id: 'event_a' },
-          { label: 'Event B', id: 'event_b' },
-        ],
-        placeholder: 'Leave empty for all events',
-        mode: 'trigger',
-        condition: { field: 'selectedTriggerId', value: '{service}_webhook' },
-      },
-      // Plus any other service-specific fields
-      ...build{Service}ExtraFields('{service}_webhook'),
-    ],
-  }),
-}
-```
-
-## Checklist Before Finishing
-
-### Utils
-- [ ] Created `{service}TriggerOptions` array with all trigger IDs
-- [ ] Created `{service}SetupInstructions` function with clear steps
-- [ ] Created `build{Service}ExtraFields` for service-specific fields
-- [ ] Created output builders for each trigger type
-
-### Triggers
-- [ ] Primary trigger has `includeDropdown: true`
-- [ ] Secondary triggers do NOT have `includeDropdown`
-- [ ] All triggers use `buildTriggerSubBlocks` helper
-- [ ] All triggers have proper outputs defined
-- [ ] Created `index.ts` barrel export
-
-### Registration
-- [ ] All triggers imported in `triggers/registry.ts`
-- [ ] All triggers added to `TRIGGER_REGISTRY`
-- [ ] Block has `triggers.enabled: true`
-- [ ] Block has all trigger IDs in `triggers.available`
-- [ ] Block spreads all trigger subBlocks: `...getTrigger('id').subBlocks`
-
-### Automatic Webhook Registration (if supported)
-- [ ] Added API key field to `build{Service}ExtraFields` with `password: true`
-- [ ] Updated setup instructions for automatic webhook creation
-- [ ] Added provider-specific logic to `apps/sim/app/api/webhooks/route.ts`
-- [ ] Added `create{Service}WebhookSubscription` helper function
-- [ ] Added `delete{Service}Webhook` function to `provider-subscriptions.ts`
-- [ ] Added provider to `cleanupExternalWebhook` function
-
-### Testing
-- [ ] Run `bun run type-check` to verify no TypeScript errors
-- [ ] Restart dev server to pick up new triggers
-- [ ] Test trigger UI shows correctly in the block
-- [ ] Test automatic webhook creation works (if applicable)

.cursor/rules/emcn-components.mdc

@@ -1,35 +1,45 @@
 ---
-description: EMCN component library patterns
+description: EMCN component library patterns with CVA
 globs: ["apps/sim/components/emcn/**"]
 ---
 
-# EMCN Components
+# EMCN Component Guidelines
 
-Import from `@/components/emcn`, never from subpaths (except CSS files).
+## When to Use CVA vs Direct Styles
 
-## CVA vs Direct Styles
+**Use CVA (class-variance-authority) when:**
+- 2+ visual variants (primary, secondary, outline)
+- Multiple sizes or state variations
+- Example: Button with variants
 
-**Use CVA when:** 2+ variants (primary/secondary, sm/md/lg)
+**Use direct className when:**
+- Single consistent style
+- No variations needed
+- Example: Label with one style
 
+## Patterns
+
+**With CVA:**
 ```tsx
 const buttonVariants = cva('base-classes', {
-  variants: { variant: { default: '...', primary: '...' } }
+  variants: { 
+    variant: { default: '...', primary: '...' },
+    size: { sm: '...', md: '...' }
+  }
 })
 export { Button, buttonVariants }
 ```
 
-**Use direct className when:** Single consistent style, no variations
-
+**Without CVA:**
 ```tsx
 function Label({ className, ...props }) {
-  return <Primitive className={cn('style-classes', className)} {...props} />
+  return <Primitive className={cn('single-style-classes', className)} {...props} />
 }
 ```
 
 ## Rules
-
 - Use Radix UI primitives for accessibility
 - Export component and variants (if using CVA)
 - TSDoc with usage examples
 - Consistent tokens: `font-medium`, `text-[12px]`, `rounded-[4px]`
-- `transition-colors` for hover states
+- Always use `transition-colors` for hover states

.cursor/rules/global.mdc

@@ -8,7 +8,7 @@ alwaysApply: true
 You are a professional software engineer. All code must follow best practices: accurate, readable, clean, and efficient.
 
 ## Logging
-Import `createLogger` from `sim/logger`. Use `logger.info`, `logger.warn`, `logger.error` instead of `console.log`.
+Use `logger.info`, `logger.warn`, `logger.error` instead of `console.log`.
 
 ## Comments
 Use TSDoc for documentation. No `====` separators. No non-TSDoc comments.

.cursor/rules/sim-architecture.mdc

@@ -10,47 +10,58 @@ globs: ["apps/sim/**"]
 2. **Composition Over Complexity**: Break down complex logic into smaller pieces
 3. **Type Safety First**: TypeScript interfaces for all props, state, return types
 4. **Predictable State**: Zustand for global state, useState for UI-only concerns
+5. **Performance by Default**: useMemo, useCallback, refs appropriately
 
-## Root-Level Structure
-
-```
-apps/sim/
-├── app/                 # Next.js app router (pages, API routes)
-├── blocks/              # Block definitions and registry
-├── components/          # Shared UI (emcn/, ui/)
-├── executor/            # Workflow execution engine
-├── hooks/               # Shared hooks (queries/, selectors/)
-├── lib/                 # App-wide utilities
-├── providers/           # LLM provider integrations
-├── stores/              # Zustand stores
-├── tools/               # Tool definitions
-└── triggers/            # Trigger definitions
-```
-
-## Feature Organization
-
-Features live under `app/workspace/[workspaceId]/`:
+## File Organization
 
 ```
 feature/
-├── components/          # Feature components
-├── hooks/               # Feature-scoped hooks
-├── utils/               # Feature-scoped utilities (2+ consumers)
-├── feature.tsx          # Main component
-└── page.tsx             # Next.js page entry
+├── components/        # Feature components
+│   └── sub-feature/   # Sub-feature with own components
+├── hooks/             # Custom hooks
+└── feature.tsx        # Main component
 ```
 
 ## Naming Conventions
-- **Components**: PascalCase (`WorkflowList`)
-- **Hooks**: `use` prefix (`useWorkflowOperations`)
-- **Files**: kebab-case (`workflow-list.tsx`)
-- **Stores**: `stores/feature/store.ts`
+- **Components**: PascalCase (`WorkflowList`, `TriggerPanel`)
+- **Hooks**: camelCase with `use` prefix (`useWorkflowOperations`)
+- **Files**: kebab-case matching export (`workflow-list.tsx`)
+- **Stores**: kebab-case in stores/ (`sidebar/store.ts`)
 - **Constants**: SCREAMING_SNAKE_CASE
 - **Interfaces**: PascalCase with suffix (`WorkflowListProps`)
 
-## Utils Rules
+## State Management
 
-- **Never create `utils.ts` for single consumer** - inline it
-- **Create `utils.ts` when** 2+ files need the same helper
-- **Check existing sources** before duplicating (`lib/` has many utilities)
-- **Location**: `lib/` (app-wide) → `feature/utils/` (feature-scoped) → inline (single-use)
+**useState**: UI-only concerns (dropdown open, hover, form inputs)
+**Zustand**: Shared state, persistence, global app state
+**useRef**: DOM refs, avoiding dependency issues, mutable non-reactive values
+
+## Component Extraction
+
+**Extract to separate file when:**
+- Complex (50+ lines)
+- Used across 2+ files
+- Has own state/logic
+
+**Keep inline when:**
+- Simple (< 10 lines)
+- Used in only 1 file
+- Purely presentational
+
+**Never import utilities from another component file.** Extract shared helpers to `lib/` or `utils/`.
+
+## Utils Files
+
+**Never create a `utils.ts` file for a single consumer.** Inline the logic directly in the consuming component.
+
+**Create `utils.ts` when:**
+- 2+ files import the same helper
+
+**Prefer existing sources of truth:**
+- Before duplicating logic, check if a centralized helper already exists (e.g., `lib/logs/get-trigger-options.ts`)
+- Import from the source of truth rather than creating wrapper functions
+
+**Location hierarchy:**
+- `lib/` — App-wide utilities (auth, billing, core)
+- `feature/utils.ts` — Feature-scoped utilities (used by 2+ components in the feature)
+- Inline — Single-use helpers (define directly in the component)

.cursor/rules/sim-components.mdc

@@ -6,43 +6,59 @@ globs: ["apps/sim/**/*.tsx"]
 # Component Patterns
 
 ## Structure Order
-
 ```typescript
 'use client' // Only if using hooks
 
-// Imports (external → internal)
-// Constants at module level
+// 1. Imports (external → internal → relative)
+// 2. Constants at module level
 const CONFIG = { SPACING: 8 } as const
 
-// Props interface
+// 3. Props interface with TSDoc
 interface ComponentProps {
+  /** Description */
   requiredProp: string
   optionalProp?: boolean
 }
 
+// 4. Component with TSDoc
 export function Component({ requiredProp, optionalProp = false }: ComponentProps) {
   // a. Refs
   // b. External hooks (useParams, useRouter)
   // c. Store hooks
   // d. Custom hooks
   // e. Local state
-  // f. useMemo
-  // g. useCallback
+  // f. useMemo computations
+  // g. useCallback handlers
   // h. useEffect
   // i. Return JSX
 }
 ```
 
 ## Rules
-
-1. `'use client'` only when using React hooks
+1. Add `'use client'` when using React hooks
 2. Always define props interface
-3. Extract constants with `as const`
-4. Semantic HTML (`aside`, `nav`, `article`)
-5. Optional chain callbacks: `onAction?.(id)`
+3. TSDoc on component: description, @param, @returns
+4. Extract constants with `as const`
+5. Use Tailwind only, no inline styles
+6. Semantic HTML (`aside`, `nav`, `article`)
+7. Include ARIA attributes where appropriate
+8. Optional chain callbacks: `onAction?.(id)`
 
-## Component Extraction
+## Factory Pattern with Caching
 
-**Extract when:** 50+ lines, used in 2+ files, or has own state/logic
+When generating components for a specific signature (e.g., icons):
 
-**Keep inline when:** < 10 lines, single use, purely presentational
+```typescript
+const cache = new Map<string, React.ComponentType<{ className?: string }>>()
+
+function getColorIcon(color: string) {
+  if (cache.has(color)) return cache.get(color)!
+  
+  const Icon = ({ className }: { className?: string }) => (
+    <div className={cn(className, 'rounded-[3px]')} style={{ backgroundColor: color, width: 10, height: 10 }} />
+  )
+  Icon.displayName = `ColorIcon(${color})`
+  cache.set(color, Icon)
+  return Icon
+}
+```

.cursor/rules/sim-hooks.mdc

@@ -6,13 +6,21 @@ globs: ["apps/sim/**/use-*.ts", "apps/sim/**/hooks/**/*.ts"]
 # Hook Patterns
 
 ## Structure
-
 ```typescript
+import { createLogger } from '@/lib/logs/console/logger'
+
+const logger = createLogger('useFeatureName')
+
 interface UseFeatureProps {
   id: string
   onSuccess?: (result: Result) => void
 }
 
+/**
+ * Hook description.
+ * @param props - Configuration
+ * @returns State and operations
+ */
 export function useFeature({ id, onSuccess }: UseFeatureProps) {
   // 1. Refs for stable dependencies
   const idRef = useRef(id)
@@ -21,6 +29,7 @@ export function useFeature({ id, onSuccess }: UseFeatureProps) {
   // 2. State
   const [data, setData] = useState<Data | null>(null)
   const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
 
   // 3. Sync refs
   useEffect(() => {
@@ -28,27 +37,32 @@ export function useFeature({ id, onSuccess }: UseFeatureProps) {
     onSuccessRef.current = onSuccess
   }, [id, onSuccess])
 
-  // 4. Operations (useCallback with empty deps when using refs)
+  // 4. Operations with useCallback
   const fetchData = useCallback(async () => {
     setIsLoading(true)
     try {
       const result = await fetch(`/api/${idRef.current}`).then(r => r.json())
       setData(result)
       onSuccessRef.current?.(result)
+    } catch (err) {
+      setError(err as Error)
+      logger.error('Failed', { error: err })
     } finally {
       setIsLoading(false)
     }
-  }, [])
+  }, []) // Empty deps - using refs
 
-  return { data, isLoading, fetchData }
+  // 5. Return grouped by state/operations
+  return { data, isLoading, error, fetchData }
 }
 ```
 
 ## Rules
-
 1. Single responsibility per hook
 2. Props interface required
-3. Refs for stable callback dependencies
-4. Wrap returned functions in useCallback
-5. Always try/catch async operations
-6. Track loading/error states
+3. TSDoc required
+4. Use logger, not console.log
+5. Refs for stable callback dependencies
+6. Wrap returned functions in useCallback
+7. Always try/catch async operations
+8. Track loading/error states

.cursor/rules/sim-imports.mdc

@@ -5,57 +5,33 @@ globs: ["apps/sim/**/*.ts", "apps/sim/**/*.tsx"]
 
 # Import Patterns
 
-## Absolute Imports
+## EMCN Components
+Import from `@/components/emcn`, never from subpaths like `@/components/emcn/components/modal/modal`.
 
-**Always use absolute imports.** Never use relative imports.
+**Exception**: CSS imports use actual file paths: `import '@/components/emcn/components/code/code.css'`
 
+## Feature Components
+Import from central folder indexes, not specific subfolders:
 ```typescript
-// ✓ Good
-import { useWorkflowStore } from '@/stores/workflows/store'
-import { Button } from '@/components/ui/button'
-
-// ✗ Bad
-import { useWorkflowStore } from '../../../stores/workflows/store'
-```
-
-## Barrel Exports
-
-Use barrel exports (`index.ts`) when a folder has 3+ exports. Import from barrel, not individual files.
-
-```typescript
-// ✓ Good
+// ✅ Correct
 import { Dashboard, Sidebar } from '@/app/workspace/[workspaceId]/logs/components'
 
-// ✗ Bad
-import { Dashboard } from '@/app/workspace/[workspaceId]/logs/components/dashboard/dashboard'
+// ❌ Wrong
+import { Dashboard } from '@/app/workspace/[workspaceId]/logs/components/dashboard'
 ```
 
-## No Re-exports
-
-Do not re-export from non-barrel files. Import directly from the source.
-
-```typescript
-// ✓ Good - import from where it's declared
-import { CORE_TRIGGER_TYPES } from '@/stores/logs/filters/types'
-
-// ✗ Bad - re-exporting in utils.ts then importing from there
-import { CORE_TRIGGER_TYPES } from '@/app/workspace/.../utils'
-```
+## Internal vs External
+- **Cross-feature**: Absolute paths through central index
+- **Within feature**: Relative paths (`./components/...`, `../utils`)
 
 ## Import Order
-
 1. React/core libraries
 2. External libraries
 3. UI components (`@/components/emcn`, `@/components/ui`)
 4. Utilities (`@/lib/...`)
-5. Stores (`@/stores/...`)
-6. Feature imports
+5. Feature imports from indexes
+6. Relative imports
 7. CSS imports
 
-## Type Imports
-
-Use `type` keyword for type-only imports:
-
-```typescript
-import type { WorkflowLog } from '@/stores/logs/types'
-```
+## Types
+Use `type` keyword: `import type { WorkflowLog } from '...'`

.cursor/rules/sim-integrations.mdc

@@ -1,207 +0,0 @@
----
-description: Adding new integrations (tools, blocks, triggers)
-globs: ["apps/sim/tools/**", "apps/sim/blocks/**", "apps/sim/triggers/**"]
----
-
-# Adding Integrations
-
-## Overview
-
-Adding a new integration typically requires:
-1. **Tools** - API operations (`tools/{service}/`)
-2. **Block** - UI component (`blocks/blocks/{service}.ts`)
-3. **Icon** - SVG icon (`components/icons.tsx`)
-4. **Trigger** (optional) - Webhooks/polling (`triggers/{service}/`)
-
-Always look up the service's API docs first.
-
-## 1. Tools (`tools/{service}/`)
-
-```
-tools/{service}/
-├── index.ts           # Export all tools
-├── types.ts           # Params/response types
-├── {action}.ts        # Individual tool (e.g., send_message.ts)
-└── ...
-```
-
-**Tool file structure:**
-
-```typescript
-// tools/{service}/{action}.ts
-import type { {Service}Params, {Service}Response } from '@/tools/{service}/types'
-import type { ToolConfig } from '@/tools/types'
-
-export const {service}{Action}Tool: ToolConfig<{Service}Params, {Service}Response> = {
-  id: '{service}_{action}',
-  name: '{Service} {Action}',
-  description: 'What this tool does',
-  version: '1.0.0',
-  oauth: { required: true, provider: '{service}' }, // if OAuth
-  params: { /* param definitions */ },
-  request: {
-    url: '/api/tools/{service}/{action}',
-    method: 'POST',
-    headers: () => ({ 'Content-Type': 'application/json' }),
-    body: (params) => ({ ...params }),
-  },
-  transformResponse: async (response) => {
-    const data = await response.json()
-    if (!data.success) throw new Error(data.error)
-    return { success: true, output: data.output }
-  },
-  outputs: { /* output definitions */ },
-}
-```
-
-**Register in `tools/registry.ts`:**
-
-```typescript
-import { {service}{Action}Tool } from '@/tools/{service}'
-// Add to registry object
-{service}_{action}: {service}{Action}Tool,
-```
-
-## 2. Block (`blocks/blocks/{service}.ts`)
-
-```typescript
-import { {Service}Icon } from '@/components/icons'
-import type { BlockConfig } from '@/blocks/types'
-import type { {Service}Response } from '@/tools/{service}/types'
-
-export const {Service}Block: BlockConfig<{Service}Response> = {
-  type: '{service}',
-  name: '{Service}',
-  description: 'Short description',
-  longDescription: 'Detailed description',
-  category: 'tools',
-  bgColor: '#hexcolor',
-  icon: {Service}Icon,
-  subBlocks: [ /* see SubBlock Properties below */ ],
-  tools: {
-    access: ['{service}_{action}', ...],
-    config: {
-      tool: (params) => `{service}_${params.operation}`,
-      params: (params) => ({ ...params }),
-    },
-  },
-  inputs: { /* input definitions */ },
-  outputs: { /* output definitions */ },
-}
-```
-
-### SubBlock Properties
-
-```typescript
-{
-  id: 'fieldName',           // Unique identifier
-  title: 'Field Label',      // UI label
-  type: 'short-input',       // See SubBlock Types below
-  placeholder: 'Hint text',
-  required: true,            // See Required below
-  condition: { ... },        // See Condition below
-  dependsOn: ['otherField'], // See DependsOn below
-  mode: 'basic',             // 'basic' | 'advanced' | 'both' | 'trigger'
-}
-```
-
-**SubBlock Types:** `short-input`, `long-input`, `dropdown`, `code`, `switch`, `slider`, `oauth-input`, `channel-selector`, `user-selector`, `file-upload`, etc.
-
-### `condition` - Show/hide based on another field
-
-```typescript
-// Show when operation === 'send'
-condition: { field: 'operation', value: 'send' }
-
-// Show when operation is 'send' OR 'read'
-condition: { field: 'operation', value: ['send', 'read'] }
-
-// Show when operation !== 'send'
-condition: { field: 'operation', value: 'send', not: true }
-
-// Complex: NOT in list AND another condition
-condition: {
-  field: 'operation',
-  value: ['list_channels', 'list_users'],
-  not: true,
-  and: { field: 'destinationType', value: 'dm', not: true }
-}
-```
-
-### `required` - Field validation
-
-```typescript
-// Always required
-required: true
-
-// Conditionally required (same syntax as condition)
-required: { field: 'operation', value: 'send' }
-```
-
-### `dependsOn` - Clear field when dependencies change
-
-```typescript
-// Clear when credential changes
-dependsOn: ['credential']
-
-// Clear when authMethod changes AND (credential OR botToken) changes
-dependsOn: { all: ['authMethod'], any: ['credential', 'botToken'] }
-```
-
-### `mode` - When to show field
-
-- `'basic'` - Only in basic mode (default UI)
-- `'advanced'` - Only in advanced mode (manual input)
-- `'both'` - Show in both modes (default)
-- `'trigger'` - Only when block is used as trigger
-
-**Register in `blocks/registry.ts`:**
-
-```typescript
-import { {Service}Block } from '@/blocks/blocks/{service}'
-// Add to registry object (alphabetically)
-{service}: {Service}Block,
-```
-
-## 3. Icon (`components/icons.tsx`)
-
-```typescript
-export function {Service}Icon(props: SVGProps<SVGSVGElement>) {
-  return (
-    <svg {...props} viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-      {/* SVG path from service's brand assets */}
-    </svg>
-  )
-}
-```
-
-## 4. Trigger (`triggers/{service}/`) - Optional
-
-```
-triggers/{service}/
-├── index.ts           # Export all triggers
-├── webhook.ts         # Webhook handler
-├── utils.ts           # Shared utilities
-└── {event}.ts         # Specific event handlers
-```
-
-**Register in `triggers/registry.ts`:**
-
-```typescript
-import { {service}WebhookTrigger } from '@/triggers/{service}'
-// Add to TRIGGER_REGISTRY
-{service}_webhook: {service}WebhookTrigger,
-```
-
-## Checklist
-
-- [ ] Look up API docs for the service
-- [ ] Create `tools/{service}/types.ts` with proper types
-- [ ] Create tool files for each operation
-- [ ] Create `tools/{service}/index.ts` barrel export
-- [ ] Register tools in `tools/registry.ts`
-- [ ] Add icon to `components/icons.tsx`
-- [ ] Create block in `blocks/blocks/{service}.ts`
-- [ ] Register block in `blocks/registry.ts`
-- [ ] (Optional) Create triggers in `triggers/{service}/`
-- [ ] (Optional) Register triggers in `triggers/registry.ts`

.cursor/rules/sim-queries.mdc

@@ -1,66 +0,0 @@
----
-description: React Query patterns for the Sim application
-globs: ["apps/sim/hooks/queries/**/*.ts"]
----
-
-# React Query Patterns
-
-All React Query hooks live in `hooks/queries/`.
-
-## Query Key Factory
-
-Every query file defines a keys factory:
-
-```typescript
-export const entityKeys = {
-  all: ['entity'] as const,
-  list: (workspaceId?: string) => [...entityKeys.all, 'list', workspaceId ?? ''] as const,
-  detail: (id?: string) => [...entityKeys.all, 'detail', id ?? ''] as const,
-}
-```
-
-## File Structure
-
-```typescript
-// 1. Query keys factory
-// 2. Types (if needed)
-// 3. Private fetch functions
-// 4. Exported hooks
-```
-
-## Query Hook
-
-```typescript
-export function useEntityList(workspaceId?: string, options?: { enabled?: boolean }) {
-  return useQuery({
-    queryKey: entityKeys.list(workspaceId),
-    queryFn: () => fetchEntities(workspaceId as string),
-    enabled: Boolean(workspaceId) && (options?.enabled ?? true),
-    staleTime: 60 * 1000,
-    placeholderData: keepPreviousData,
-  })
-}
-```
-
-## Mutation Hook
-
-```typescript
-export function useCreateEntity() {
-  const queryClient = useQueryClient()
-  return useMutation({
-    mutationFn: async (variables) => { /* fetch POST */ },
-    onSuccess: () => queryClient.invalidateQueries({ queryKey: entityKeys.all }),
-  })
-}
-```
-
-## Optimistic Updates
-
-For optimistic mutations syncing with Zustand, use `createOptimisticMutationHandlers` from `@/hooks/queries/utils/optimistic-mutation`.
-
-## Naming
-
-- **Keys**: `entityKeys`
-- **Query hooks**: `useEntity`, `useEntityList`
-- **Mutation hooks**: `useCreateEntity`, `useUpdateEntity`
-- **Fetch functions**: `fetchEntity` (private)

.cursor/rules/sim-stores.mdc

@@ -5,66 +5,53 @@ globs: ["apps/sim/**/store.ts", "apps/sim/**/stores/**/*.ts"]
 
 # Zustand Store Patterns
 
-Stores live in `stores/`. Complex stores split into `store.ts` + `types.ts`.
-
-## Basic Store
-
-```typescript
-import { create } from 'zustand'
-import { devtools } from 'zustand/middleware'
-import type { FeatureState } from '@/stores/feature/types'
-
-const initialState = { items: [] as Item[], activeId: null as string | null }
-
-export const useFeatureStore = create<FeatureState>()(
-  devtools(
-    (set, get) => ({
-      ...initialState,
-      setItems: (items) => set({ items }),
-      addItem: (item) => set((state) => ({ items: [...state.items, item] })),
-      reset: () => set(initialState),
-    }),
-    { name: 'feature-store' }
-  )
-)
-```
-
-## Persisted Store
-
+## Structure
 ```typescript
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
 
+interface FeatureState {
+  // State
+  items: Item[]
+  activeId: string | null
+  
+  // Actions
+  setItems: (items: Item[]) => void
+  addItem: (item: Item) => void
+  clearState: () => void
+}
+
+const createInitialState = () => ({
+  items: [],
+  activeId: null,
+})
+
 export const useFeatureStore = create<FeatureState>()(
   persist(
     (set) => ({
-      width: 300,
-      setWidth: (width) => set({ width }),
-      _hasHydrated: false,
-      setHasHydrated: (v) => set({ _hasHydrated: v }),
+      ...createInitialState(),
+
+      setItems: (items) => set({ items }),
+
+      addItem: (item) => set((state) => ({
+        items: [...state.items, item],
+      })),
+
+      clearState: () => set(createInitialState()),
     }),
     {
       name: 'feature-state',
-      partialize: (state) => ({ width: state.width }),
-      onRehydrateStorage: () => (state) => state?.setHasHydrated(true),
+      partialize: (state) => ({ items: state.items }),
     }
   )
 )
 ```
 
 ## Rules
-
-1. Use `devtools` middleware (named stores)
-2. Use `persist` only when data should survive reload
-3. `partialize` to persist only necessary state
-4. `_hasHydrated` pattern for persisted stores needing hydration tracking
-5. Immutable updates only
-6. `set((state) => ...)` when depending on previous state
-7. Provide `reset()` action
-
-## Outside React
-
-```typescript
-const items = useFeatureStore.getState().items
-useFeatureStore.setState({ items: newItems })
-```
+1. Interface includes state and actions
+2. Extract config to module constants
+3. TSDoc on store
+4. Only persist what's needed
+5. Immutable updates only - never mutate
+6. Use `set((state) => ...)` when depending on previous state
+7. Provide clear/reset actions

.cursor/rules/sim-styling.mdc

@@ -6,14 +6,13 @@ globs: ["apps/sim/**/*.tsx", "apps/sim/**/*.css"]
 # Styling Rules
 
 ## Tailwind
-
-1. **No inline styles** - Use Tailwind classes
-2. **No duplicate dark classes** - Skip `dark:` when value matches light mode
-3. **Exact values** - `text-[14px]`, `h-[26px]`
-4. **Transitions** - `transition-colors` for interactive states
+1. **No inline styles** - Use Tailwind classes exclusively
+2. **No duplicate dark classes** - Don't add `dark:` when value matches light mode
+3. **Exact values** - Use design system values (`text-[14px]`, `h-[25px]`)
+4. **Prefer px** - Use `px-[4px]` over `px-1`
+5. **Transitions** - Add `transition-colors` for interactive states
 
 ## Conditional Classes
-
 ```typescript
 import { cn } from '@/lib/utils'
 
@@ -24,17 +23,25 @@ import { cn } from '@/lib/utils'
 )} />
 ```
 
-## CSS Variables
-
-For dynamic values (widths, heights) synced with stores:
-
+## CSS Variables for Dynamic Styles
 ```typescript
-// In store
-setWidth: (width) => {
-  set({ width })
+// In store setter
+setSidebarWidth: (width) => {
+  set({ sidebarWidth: width })
   document.documentElement.style.setProperty('--sidebar-width', `${width}px`)
 }
 
 // In component
 <aside style={{ width: 'var(--sidebar-width)' }} />
 ```
+
+## Anti-Patterns
+```typescript
+// ❌ Bad
+<div style={{ width: 200 }}>
+<div className='text-[var(--text-primary)] dark:text-[var(--text-primary)]'>
+
+// ✅ Good
+<div className='w-[200px]'>
+<div className='text-[var(--text-primary)]'>
+```

.cursor/rules/sim-testing.mdc

@@ -1,57 +0,0 @@
----
-description: Testing patterns with Vitest and @sim/testing
-globs: ["apps/sim/**/*.test.ts", "apps/sim/**/*.test.tsx"]
----
-
-# Testing Patterns
-
-Use Vitest. Test files: `feature.ts` → `feature.test.ts`
-
-## Structure
-
-```typescript
-/**
- * @vitest-environment node
- */
-import { databaseMock, loggerMock } from '@sim/testing'
-import { describe, expect, it, vi } from 'vitest'
-
-vi.mock('@sim/db', () => databaseMock)
-vi.mock('@sim/logger', () => loggerMock)
-
-import { myFunction } from '@/lib/feature'
-
-describe('myFunction', () => {
-  beforeEach(() => vi.clearAllMocks())
-  it.concurrent('isolated tests run in parallel', () => { ... })
-})
-```
-
-## @sim/testing Package
-
-Always prefer over local mocks.
-
-| Category | Utilities |
-|----------|-----------|
-| **Mocks** | `loggerMock`, `databaseMock`, `setupGlobalFetchMock()` |
-| **Factories** | `createSession()`, `createWorkflowRecord()`, `createBlock()`, `createExecutorContext()` |
-| **Builders** | `WorkflowBuilder`, `ExecutionContextBuilder` |
-| **Assertions** | `expectWorkflowAccessGranted()`, `expectBlockExecuted()` |
-
-## Rules
-
-1. `@vitest-environment node` directive at file top
-2. `vi.mock()` calls before importing mocked modules
-3. `@sim/testing` utilities over local mocks
-4. `it.concurrent` for isolated tests (no shared mutable state)
-5. `beforeEach(() => vi.clearAllMocks())` to reset state
-
-## Hoisted Mocks
-
-For mutable mock references:
-
-```typescript
-const mockFn = vi.hoisted(() => vi.fn())
-vi.mock('@/lib/module', () => ({ myFunction: mockFn }))
-mockFn.mockResolvedValue({ data: 'test' })
-```

.cursor/rules/sim-typescript.mdc

@@ -6,15 +6,19 @@ globs: ["apps/sim/**/*.ts", "apps/sim/**/*.tsx"]
 # TypeScript Rules
 
 1. **No `any`** - Use proper types or `unknown` with type guards
-2. **Props interface** - Always define for components
-3. **Const assertions** - `as const` for constant objects/arrays
-4. **Ref types** - Explicit: `useRef<HTMLDivElement>(null)`
-5. **Type imports** - `import type { X }` for type-only imports
+2. **Props interface** - Always define, even for simple components
+3. **Callback types** - Full signature with params and return type
+4. **Generics** - Use for reusable components/hooks
+5. **Const assertions** - `as const` for constant objects/arrays
+6. **Ref types** - Explicit: `useRef<HTMLDivElement>(null)`
 
+## Anti-Patterns
 ```typescript
-// ✗ Bad
+// ❌ Bad
 const handleClick = (e: any) => {}
+useEffect(() => { doSomething(prop) }, []) // Missing dep
 
-// ✓ Good
+// ✅ Good  
 const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => {}
+useEffect(() => { doSomething(prop) }, [prop])
 ```

.github/workflows/test-build.yml

@@ -23,17 +23,16 @@ jobs:
         with:
           node-version: latest
 
-      - name: Mount Bun cache (Sticky Disk)
-        uses: useblacksmith/stickydisk@v1
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
         with:
-          key: ${{ github.repository }}-bun-cache
-          path: ~/.bun/install/cache
-
-      - name: Mount node_modules (Sticky Disk)
-        uses: useblacksmith/stickydisk@v1
-        with:
-          key: ${{ github.repository }}-node-modules
-          path: ./node_modules
+          path: |
+            ~/.bun/install/cache
+            node_modules
+            **/node_modules
+          key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-bun-
 
       - name: Install dependencies
         run: bun install --frozen-lockfile

CLAUDE.md

@@ -1,295 +1,47 @@
-# Sim Studio Development Guidelines
+# Expert Programming Standards
 
-You are a professional software engineer. All code must follow best practices: accurate, readable, clean, and efficient.
+**You are tasked with implementing solutions that follow best practices. You MUST be accurate, elegant, and efficient as an expert programmer.**
 
-## Global Standards
+---
 
-- **Logging**: Import `createLogger` from `@sim/logger`. Use `logger.info`, `logger.warn`, `logger.error` instead of `console.log`
-- **Comments**: Use TSDoc for documentation. No `====` separators. No non-TSDoc comments
-- **Styling**: Never update global styles. Keep all styling local to components
-- **Package Manager**: Use `bun` and `bunx`, not `npm` and `npx`
+# Role
 
-## Architecture
+You are a professional software engineer. All code you write MUST follow best practices, ensuring accuracy, quality, readability, and cleanliness. You MUST make FOCUSED EDITS that are EFFICIENT and ELEGANT.
 
-### Core Principles
-1. Single Responsibility: Each component, hook, store has one clear purpose
-2. Composition Over Complexity: Break down complex logic into smaller pieces
-3. Type Safety First: TypeScript interfaces for all props, state, return types
-4. Predictable State: Zustand for global state, useState for UI-only concerns
+## Logs
 
-### Root Structure
-```
-apps/sim/
-├── app/           # Next.js app router (pages, API routes)
-├── blocks/        # Block definitions and registry
-├── components/    # Shared UI (emcn/, ui/)
-├── executor/      # Workflow execution engine
-├── hooks/         # Shared hooks (queries/, selectors/)
-├── lib/           # App-wide utilities
-├── providers/     # LLM provider integrations
-├── stores/        # Zustand stores
-├── tools/         # Tool definitions
-└── triggers/      # Trigger definitions
-```
+ENSURE that you use the logger.info and logger.warn and logger.error instead of the console.log whenever you want to display logs.
 
-### Naming Conventions
-- Components: PascalCase (`WorkflowList`)
-- Hooks: `use` prefix (`useWorkflowOperations`)
-- Files: kebab-case (`workflow-list.tsx`)
-- Stores: `stores/feature/store.ts`
-- Constants: SCREAMING_SNAKE_CASE
-- Interfaces: PascalCase with suffix (`WorkflowListProps`)
+## Comments
 
-## Imports
+You must use TSDOC for comments. Do not use ==== for comments to separate sections. Do not leave any comments that are not TSDOC.
 
-**Always use absolute imports.** Never use relative imports.
+## Global Styles
 
-```typescript
-// ✓ Good
-import { useWorkflowStore } from '@/stores/workflows/store'
+You should not update the global styles unless it is absolutely necessary. Keep all styling local to components and files.
 
-// ✗ Bad
-import { useWorkflowStore } from '../../../stores/workflows/store'
-```
+## Bun
 
-Use barrel exports (`index.ts`) when a folder has 3+ exports. Do not re-export from non-barrel files; import directly from the source.
+Use bun and bunx not npm and npx.
 
-### Import Order
-1. React/core libraries
-2. External libraries
-3. UI components (`@/components/emcn`, `@/components/ui`)
-4. Utilities (`@/lib/...`)
-5. Stores (`@/stores/...`)
-6. Feature imports
-7. CSS imports
+## Code Quality
 
-Use `import type { X }` for type-only imports.
-
-## TypeScript
-
-1. No `any` - Use proper types or `unknown` with type guards
-2. Always define props interface for components
-3. `as const` for constant objects/arrays
-4. Explicit ref types: `useRef<HTMLDivElement>(null)`
-
-## Components
-
-```typescript
-'use client' // Only if using hooks
-
-const CONFIG = { SPACING: 8 } as const
-
-interface ComponentProps {
-  requiredProp: string
-  optionalProp?: boolean
-}
-
-export function Component({ requiredProp, optionalProp = false }: ComponentProps) {
-  // Order: refs → external hooks → store hooks → custom hooks → state → useMemo → useCallback → useEffect → return
-}
-```
-
-Extract when: 50+ lines, used in 2+ files, or has own state/logic. Keep inline when: < 10 lines, single use, purely presentational.
-
-## Hooks
-
-```typescript
-interface UseFeatureProps { id: string }
-
-export function useFeature({ id }: UseFeatureProps) {
-  const idRef = useRef(id)
-  const [data, setData] = useState<Data | null>(null)
-  
-  useEffect(() => { idRef.current = id }, [id])
-  
-  const fetchData = useCallback(async () => { ... }, []) // Empty deps when using refs
-  
-  return { data, fetchData }
-}
-```
-
-## Zustand Stores
-
-Stores live in `stores/`. Complex stores split into `store.ts` + `types.ts`.
-
-```typescript
-import { create } from 'zustand'
-import { devtools } from 'zustand/middleware'
-
-const initialState = { items: [] as Item[] }
-
-export const useFeatureStore = create<FeatureState>()(
-  devtools(
-    (set, get) => ({
-      ...initialState,
-      setItems: (items) => set({ items }),
-      reset: () => set(initialState),
-    }),
-    { name: 'feature-store' }
-  )
-)
-```
-
-Use `devtools` middleware. Use `persist` only when data should survive reload with `partialize` to persist only necessary state.
-
-## React Query
-
-All React Query hooks live in `hooks/queries/`.
-
-```typescript
-export const entityKeys = {
-  all: ['entity'] as const,
-  list: (workspaceId?: string) => [...entityKeys.all, 'list', workspaceId ?? ''] as const,
-}
-
-export function useEntityList(workspaceId?: string) {
-  return useQuery({
-    queryKey: entityKeys.list(workspaceId),
-    queryFn: () => fetchEntities(workspaceId as string),
-    enabled: Boolean(workspaceId),
-    staleTime: 60 * 1000,
-    placeholderData: keepPreviousData,
-  })
-}
-```
-
-## Styling
-
-Use Tailwind only, no inline styles. Use `cn()` from `@/lib/utils` for conditional classes.
-
-```typescript
-<div className={cn('base-classes', isActive && 'active-classes')} />
-```
-
-## EMCN Components
-
-Import from `@/components/emcn`, never from subpaths (except CSS files). Use CVA when 2+ variants exist.
+- Write clean, maintainable code that follows the project's existing patterns
+- Prefer composition over inheritance
+- Keep functions small and focused on a single responsibility
+- Use meaningful variable and function names
+- Handle errors gracefully and provide useful error messages
+- Write type-safe code with proper TypeScript types
 
 ## Testing
 
-Use Vitest. Test files: `feature.ts` → `feature.test.ts`
+- Write tests for new functionality when appropriate
+- Ensure existing tests pass before completing work
+- Follow the project's testing conventions
 
-```typescript
-/**
- * @vitest-environment node
- */
-import { databaseMock, loggerMock } from '@sim/testing'
-import { describe, expect, it, vi } from 'vitest'
+## Performance
 
-vi.mock('@sim/db', () => databaseMock)
-vi.mock('@sim/logger', () => loggerMock)
-
-import { myFunction } from '@/lib/feature'
-
-describe('feature', () => {
-  beforeEach(() => vi.clearAllMocks())
-  it.concurrent('runs in parallel', () => { ... })
-})
-```
-
-Use `@sim/testing` mocks/factories over local test data. See `.cursor/rules/sim-testing.mdc` for details.
-
-## Utils Rules
-
-- Never create `utils.ts` for single consumer - inline it
-- Create `utils.ts` when 2+ files need the same helper
-- Check existing sources in `lib/` before duplicating
-
-## Adding Integrations
-
-New integrations require: **Tools** → **Block** → **Icon** → (optional) **Trigger**
-
-Always look up the service's API docs first.
-
-### 1. Tools (`tools/{service}/`)
-
-```
-tools/{service}/
-├── index.ts      # Barrel export
-├── types.ts      # Params/response types
-└── {action}.ts   # Tool implementation
-```
-
-**Tool structure:**
-```typescript
-export const serviceTool: ToolConfig<Params, Response> = {
-  id: 'service_action',
-  name: 'Service Action',
-  description: '...',
-  version: '1.0.0',
-  oauth: { required: true, provider: 'service' },
-  params: { /* ... */ },
-  request: { url: '/api/tools/service/action', method: 'POST', ... },
-  transformResponse: async (response) => { /* ... */ },
-  outputs: { /* ... */ },
-}
-```
-
-Register in `tools/registry.ts`.
-
-### 2. Block (`blocks/blocks/{service}.ts`)
-
-```typescript
-export const ServiceBlock: BlockConfig = {
-  type: 'service',
-  name: 'Service',
-  description: '...',
-  category: 'tools',
-  bgColor: '#hexcolor',
-  icon: ServiceIcon,
-  subBlocks: [ /* see SubBlock Properties */ ],
-  tools: { access: ['service_action'], config: { tool: (p) => `service_${p.operation}` } },
-  inputs: { /* ... */ },
-  outputs: { /* ... */ },
-}
-```
-
-Register in `blocks/registry.ts` (alphabetically).
-
-**SubBlock Properties:**
-```typescript
-{
-  id: 'field', title: 'Label', type: 'short-input', placeholder: '...',
-  required: true,                    // or condition object
-  condition: { field: 'op', value: 'send' },  // show/hide
-  dependsOn: ['credential'],         // clear when dep changes
-  mode: 'basic',                     // 'basic' | 'advanced' | 'both' | 'trigger'
-}
-```
-
-**condition examples:**
-- `{ field: 'op', value: 'send' }` - show when op === 'send'
-- `{ field: 'op', value: ['a','b'] }` - show when op is 'a' OR 'b'
-- `{ field: 'op', value: 'x', not: true }` - show when op !== 'x'
-- `{ field: 'op', value: 'x', not: true, and: { field: 'type', value: 'dm', not: true } }` - complex
-
-**dependsOn:** `['field']` or `{ all: ['a'], any: ['b', 'c'] }`
-
-### 3. Icon (`components/icons.tsx`)
-
-```typescript
-export function ServiceIcon(props: SVGProps<SVGSVGElement>) {
-  return <svg {...props}>/* SVG from brand assets */</svg>
-}
-```
-
-### 4. Trigger (`triggers/{service}/`) - Optional
-
-```
-triggers/{service}/
-├── index.ts      # Barrel export
-├── webhook.ts    # Webhook handler
-└── {event}.ts    # Event-specific handlers
-```
-
-Register in `triggers/registry.ts`.
-
-### Integration Checklist
-
-- [ ] Look up API docs
-- [ ] Create `tools/{service}/` with types and tools
-- [ ] Register tools in `tools/registry.ts`
-- [ ] Add icon to `components/icons.tsx`
-- [ ] Create block in `blocks/blocks/{service}.ts`
-- [ ] Register block in `blocks/registry.ts`
-- [ ] (Optional) Create and register triggers
+- Consider performance implications of your code
+- Avoid unnecessary re-renders in React components
+- Use appropriate data structures and algorithms
+- Profile and optimize when necessary

LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2026 Sim Studio, Inc.
+   Copyright 2025 Sim Studio, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

NOTICE

@@ -1,4 +1,4 @@
 Sim Studio
-Copyright 2026 Sim Studio
+Copyright 2025 Sim Studio
 
 This product includes software developed for the Sim project. 

apps/docs/app/[lang]/[[...slug]]/page.tsx

@@ -258,7 +258,8 @@ export async function generateMetadata(props: {
   const baseUrl = 'https://docs.sim.ai'
   const fullUrl = `${baseUrl}${page.url}`
 
-  const ogImageUrl = `${baseUrl}/api/og?title=${encodeURIComponent(data.title)}`
+  const description = data.description || ''
+  const ogImageUrl = `${baseUrl}/api/og?title=${encodeURIComponent(data.title)}&category=DOCUMENTATION${description ? `&description=${encodeURIComponent(description)}` : ''}`
 
   return {
     title: data.title,

apps/docs/app/api/og/route.tsx

@@ -39,10 +39,12 @@ async function loadGoogleFont(font: string, weights: string, text: string): Prom
 export async function GET(request: NextRequest) {
   const { searchParams } = new URL(request.url)
   const title = searchParams.get('title') || 'Documentation'
+  const category = searchParams.get('category') || 'DOCUMENTATION'
+  const description = searchParams.get('description') || ''
 
   const baseUrl = new URL(request.url).origin
 
-  const allText = `${title}docs.sim.ai`
+  const allText = `${title}${category}${description}docs.sim.ai`
   const fontData = await loadGoogleFont('Geist', '400;500;600', allText)
 
   return new ImageResponse(
@@ -57,7 +59,7 @@ export async function GET(request: NextRequest) {
         fontFamily: 'Geist',
       }}
     >
-      {/* Base gradient layer - subtle purple tint across the entire image */}
+      {/* Base gradient layer - very subtle purple tint across the entire image */}
       <div
         style={{
           position: 'absolute',
@@ -112,25 +114,56 @@ export async function GET(request: NextRequest) {
         {/* Logo */}
         <img src={`${baseUrl}/static/logo.png`} alt='sim' height={32} />
 
-        {/* Title */}
-        <span
+        {/* Category + Title + Description */}
+        <div
           style={{
-            fontSize: getTitleFontSize(title),
-            fontWeight: 600,
-            color: '#ffffff',
-            lineHeight: 1.1,
-            letterSpacing: '-0.02em',
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 12,
           }}
         >
-          {title}
-        </span>
+          <span
+            style={{
+              fontSize: 15,
+              fontWeight: 600,
+              color: '#802fff',
+              letterSpacing: '0.02em',
+            }}
+          >
+            {category}
+          </span>
+          <span
+            style={{
+              fontSize: getTitleFontSize(title),
+              fontWeight: 600,
+              color: '#ffffff',
+              lineHeight: 1.1,
+              letterSpacing: '-0.02em',
+            }}
+          >
+            {title}
+          </span>
+          {description && (
+            <span
+              style={{
+                fontSize: 18,
+                fontWeight: 400,
+                color: '#a1a1aa',
+                lineHeight: 1.4,
+                marginTop: 4,
+              }}
+            >
+              {description.length > 100 ? `${description.slice(0, 100)}...` : description}
+            </span>
+          )}
+        </div>
 
         {/* Footer */}
         <span
           style={{
-            fontSize: 20,
+            fontSize: 15,
             fontWeight: 500,
-            color: '#71717a',
+            color: '#52525b',
           }}
         >
           docs.sim.ai

apps/docs/app/api/search/route.ts

@@ -1,126 +1,16 @@
-import { sql } from 'drizzle-orm'
-import { type NextRequest, NextResponse } from 'next/server'
-import { db, docsEmbeddings } from '@/lib/db'
-import { generateSearchEmbedding } from '@/lib/embeddings'
+import { createFromSource } from 'fumadocs-core/search/server'
+import { source } from '@/lib/source'
 
-export const runtime = 'nodejs'
-export const revalidate = 0
+export const revalidate = 3600 // Revalidate every hour
 
-/**
- * Hybrid search API endpoint
- * - English: Vector embeddings + keyword search
- * - Other languages: Keyword search only
- */
-export async function GET(request: NextRequest) {
-  try {
-    const searchParams = request.nextUrl.searchParams
-    const query = searchParams.get('query') || searchParams.get('q') || ''
-    const locale = searchParams.get('locale') || 'en'
-    const limit = Number.parseInt(searchParams.get('limit') || '10', 10)
-
-    if (!query || query.trim().length === 0) {
-      return NextResponse.json([])
-    }
-
-    const candidateLimit = limit * 3
-    const similarityThreshold = 0.6
-
-    const localeMap: Record<string, string> = {
-      en: 'english',
-      es: 'spanish',
-      fr: 'french',
-      de: 'german',
-      ja: 'simple', // PostgreSQL doesn't have Japanese support, use simple
-      zh: 'simple', // PostgreSQL doesn't have Chinese support, use simple
-    }
-    const tsConfig = localeMap[locale] || 'simple'
-
-    const useVectorSearch = locale === 'en'
-    let vectorResults: Array<{
-      chunkId: string
-      chunkText: string
-      sourceDocument: string
-      sourceLink: string
-      headerText: string
-      headerLevel: number
-      similarity: number
-      searchType: string
-    }> = []
-
-    if (useVectorSearch) {
-      const queryEmbedding = await generateSearchEmbedding(query)
-      vectorResults = await db
-        .select({
-          chunkId: docsEmbeddings.chunkId,
-          chunkText: docsEmbeddings.chunkText,
-          sourceDocument: docsEmbeddings.sourceDocument,
-          sourceLink: docsEmbeddings.sourceLink,
-          headerText: docsEmbeddings.headerText,
-          headerLevel: docsEmbeddings.headerLevel,
-          similarity: sql<number>`1 - (${docsEmbeddings.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`,
-          searchType: sql<string>`'vector'`,
-        })
-        .from(docsEmbeddings)
-        .where(
-          sql`1 - (${docsEmbeddings.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector) >= ${similarityThreshold}`
-        )
-        .orderBy(sql`${docsEmbeddings.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`)
-        .limit(candidateLimit)
-    }
-
-    const keywordResults = await db
-      .select({
-        chunkId: docsEmbeddings.chunkId,
-        chunkText: docsEmbeddings.chunkText,
-        sourceDocument: docsEmbeddings.sourceDocument,
-        sourceLink: docsEmbeddings.sourceLink,
-        headerText: docsEmbeddings.headerText,
-        headerLevel: docsEmbeddings.headerLevel,
-        similarity: sql<number>`ts_rank(${docsEmbeddings.chunkTextTsv}, plainto_tsquery(${tsConfig}, ${query}))`,
-        searchType: sql<string>`'keyword'`,
-      })
-      .from(docsEmbeddings)
-      .where(sql`${docsEmbeddings.chunkTextTsv} @@ plainto_tsquery(${tsConfig}, ${query})`)
-      .orderBy(
-        sql`ts_rank(${docsEmbeddings.chunkTextTsv}, plainto_tsquery(${tsConfig}, ${query})) DESC`
-      )
-      .limit(candidateLimit)
-
-    const seenIds = new Set<string>()
-    const mergedResults = []
-
-    for (let i = 0; i < Math.max(vectorResults.length, keywordResults.length); i++) {
-      if (i < vectorResults.length && !seenIds.has(vectorResults[i].chunkId)) {
-        mergedResults.push(vectorResults[i])
-        seenIds.add(vectorResults[i].chunkId)
-      }
-      if (i < keywordResults.length && !seenIds.has(keywordResults[i].chunkId)) {
-        mergedResults.push(keywordResults[i])
-        seenIds.add(keywordResults[i].chunkId)
-      }
-    }
-
-    const filteredResults = mergedResults.slice(0, limit)
-    const searchResults = filteredResults.map((result) => {
-      const title = result.headerText || result.sourceDocument.replace('.mdx', '')
-      const pathParts = result.sourceDocument
-        .replace('.mdx', '')
-        .split('/')
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-
-      return {
-        id: result.chunkId,
-        type: 'page' as const,
-        url: result.sourceLink,
-        content: title,
-        breadcrumbs: pathParts,
-      }
-    })
-
-    return NextResponse.json(searchResults)
-  } catch (error) {
-    console.error('Semantic search error:', error)
-
-    return NextResponse.json([])
-  }
-}
+export const { GET } = createFromSource(source, {
+  localeMap: {
+    en: { language: 'english' },
+    es: { language: 'spanish' },
+    fr: { language: 'french' },
+    de: { language: 'german' },
+    // ja and zh are not supported by the stemmer library, so we'll skip language config for them
+    ja: {},
+    zh: {},
+  },
+})

apps/docs/app/layout.tsx

@@ -58,7 +58,7 @@ export const metadata = {
       'Comprehensive documentation for Sim - the visual workflow builder for AI applications. Create powerful AI agents, automation workflows, and data processing pipelines.',
     images: [
       {
-        url: 'https://docs.sim.ai/api/og?title=Sim%20Documentation',
+        url: 'https://docs.sim.ai/api/og?title=Sim%20Documentation&category=DOCUMENTATION',
         width: 1200,
         height: 630,
         alt: 'Sim Documentation',
@@ -72,7 +72,7 @@ export const metadata = {
       'Comprehensive documentation for Sim - the visual workflow builder for AI applications.',
     creator: '@simdotai',
     site: '@simdotai',
-    images: ['https://docs.sim.ai/api/og?title=Sim%20Documentation'],
+    images: ['https://docs.sim.ai/api/og?title=Sim%20Documentation&category=DOCUMENTATION'],
   },
   robots: {
     index: true,

apps/docs/app/llms.mdx/[[...slug]]/route.ts

@@ -6,10 +6,7 @@ import { source } from '@/lib/source'
 
 export const revalidate = false
 
-export async function GET(
-  _request: NextRequest,
-  { params }: { params: Promise<{ slug?: string[] }> }
-) {
+export async function GET(_req: NextRequest, { params }: { params: Promise<{ slug?: string[] }> }) {
   const { slug } = await params
 
   let lang: (typeof i18n.languages)[number] = i18n.defaultLanguage

apps/docs/components/ui/icon-mapping.ts

@@ -13,7 +13,6 @@ import {
   BrainIcon,
   BrowserUseIcon,
   CalendlyIcon,
-  CirclebackIcon,
   ClayIcon,
   ConfluenceIcon,
   CursorIcon,
@@ -28,7 +27,6 @@ import {
   ExaAIIcon,
   EyeIcon,
   FirecrawlIcon,
-  FirefliesIcon,
   GithubIcon,
   GitLabIcon,
   GmailIcon,
@@ -42,8 +40,6 @@ import {
   GoogleSlidesIcon,
   GoogleVaultIcon,
   GrafanaIcon,
-  GrainIcon,
-  GreptileIcon,
   HubspotIcon,
   HuggingFaceIcon,
   HunterIOIcon,
@@ -52,15 +48,12 @@ import {
   IntercomIcon,
   JinaAIIcon,
   JiraIcon,
-  JiraServiceManagementIcon,
   KalshiIcon,
-  LemlistIcon,
   LinearIcon,
   LinkedInIcon,
   LinkupIcon,
   MailchimpIcon,
   MailgunIcon,
-  MailServerIcon,
   Mem0Icon,
   MicrosoftExcelIcon,
   MicrosoftOneDriveIcon,
@@ -127,123 +120,117 @@ import {
 type IconComponent = ComponentType<SVGProps<SVGSVGElement>>
 
 export const blockTypeToIconMap: Record<string, IconComponent> = {
-  ahrefs: AhrefsIcon,
-  airtable: AirtableIcon,
-  apify: ApifyIcon,
-  apollo: ApolloIcon,
-  arxiv: ArxivIcon,
-  asana: AsanaIcon,
-  browser_use: BrowserUseIcon,
-  calendly: CalendlyIcon,
-  circleback: CirclebackIcon,
-  clay: ClayIcon,
-  confluence: ConfluenceIcon,
-  cursor_v2: CursorIcon,
-  datadog: DatadogIcon,
-  discord: DiscordIcon,
-  dropbox: DropboxIcon,
-  duckduckgo: DuckDuckGoIcon,
-  dynamodb: DynamoDBIcon,
-  elasticsearch: ElasticsearchIcon,
-  elevenlabs: ElevenLabsIcon,
-  exa: ExaAIIcon,
-  file: DocumentIcon,
-  firecrawl: FirecrawlIcon,
-  fireflies: FirefliesIcon,
-  github_v2: GithubIcon,
-  gitlab: GitLabIcon,
-  gmail_v2: GmailIcon,
-  google_calendar_v2: GoogleCalendarIcon,
-  google_docs: GoogleDocsIcon,
-  google_drive: GoogleDriveIcon,
-  google_forms: GoogleFormsIcon,
-  google_groups: GoogleGroupsIcon,
-  google_search: GoogleIcon,
-  google_sheets: GoogleSheetsIcon,
-  google_slides: GoogleSlidesIcon,
-  google_vault: GoogleVaultIcon,
-  grafana: GrafanaIcon,
-  grain: GrainIcon,
-  greptile: GreptileIcon,
-  hubspot: HubspotIcon,
-  huggingface: HuggingFaceIcon,
-  hunter: HunterIOIcon,
-  image_generator: ImageIcon,
-  imap: MailServerIcon,
-  incidentio: IncidentioIcon,
-  intercom_v2: IntercomIcon,
-  jina: JinaAIIcon,
-  jira: JiraIcon,
-  jira_service_management: JiraServiceManagementIcon,
-  kalshi: KalshiIcon,
-  knowledge: PackageSearchIcon,
-  lemlist: LemlistIcon,
-  linear: LinearIcon,
-  linkedin: LinkedInIcon,
-  linkup: LinkupIcon,
-  mailchimp: MailchimpIcon,
-  mailgun: MailgunIcon,
-  mem0: Mem0Icon,
-  memory: BrainIcon,
-  microsoft_excel: MicrosoftExcelIcon,
-  microsoft_planner: MicrosoftPlannerIcon,
-  microsoft_teams: MicrosoftTeamsIcon,
-  mistral_parse: MistralIcon,
-  mongodb: MongoDBIcon,
-  mysql: MySQLIcon,
-  neo4j: Neo4jIcon,
-  notion_v2: NotionIcon,
-  onedrive: MicrosoftOneDriveIcon,
-  openai: OpenAIIcon,
-  outlook: OutlookIcon,
-  parallel_ai: ParallelIcon,
-  perplexity: PerplexityIcon,
-  pinecone: PineconeIcon,
-  pipedrive: PipedriveIcon,
-  polymarket: PolymarketIcon,
-  postgresql: PostgresIcon,
-  posthog: PosthogIcon,
-  qdrant: QdrantIcon,
-  rds: RDSIcon,
-  reddit: RedditIcon,
-  resend: ResendIcon,
-  s3: S3Icon,
-  salesforce: SalesforceIcon,
-  search: SearchIcon,
-  sendgrid: SendgridIcon,
-  sentry: SentryIcon,
-  serper: SerperIcon,
-  servicenow: ServiceNowIcon,
-  sftp: SftpIcon,
-  sharepoint: MicrosoftSharepointIcon,
-  shopify: ShopifyIcon,
-  slack: SlackIcon,
-  smtp: SmtpIcon,
-  spotify: SpotifyIcon,
-  sqs: SQSIcon,
-  ssh: SshIcon,
-  stagehand: StagehandIcon,
-  stripe: StripeIcon,
-  stt: STTIcon,
-  supabase: SupabaseIcon,
-  tavily: TavilyIcon,
-  telegram: TelegramIcon,
-  translate: TranslateIcon,
-  trello: TrelloIcon,
-  tts: TTSIcon,
-  twilio_sms: TwilioIcon,
-  twilio_voice: TwilioIcon,
-  typeform: TypeformIcon,
-  video_generator: VideoIcon,
-  vision: EyeIcon,
-  wealthbox: WealthboxIcon,
-  webflow: WebflowIcon,
-  whatsapp: WhatsAppIcon,
-  wikipedia: WikipediaIcon,
-  wordpress: WordpressIcon,
-  x: xIcon,
-  youtube: YouTubeIcon,
-  zendesk: ZendeskIcon,
-  zep: ZepIcon,
   zoom: ZoomIcon,
+  zep: ZepIcon,
+  zendesk: ZendeskIcon,
+  youtube: YouTubeIcon,
+  x: xIcon,
+  wordpress: WordpressIcon,
+  wikipedia: WikipediaIcon,
+  whatsapp: WhatsAppIcon,
+  webflow: WebflowIcon,
+  wealthbox: WealthboxIcon,
+  vision: EyeIcon,
+  video_generator: VideoIcon,
+  typeform: TypeformIcon,
+  twilio_voice: TwilioIcon,
+  twilio_sms: TwilioIcon,
+  tts: TTSIcon,
+  trello: TrelloIcon,
+  translate: TranslateIcon,
+  thinking: BrainIcon,
+  telegram: TelegramIcon,
+  tavily: TavilyIcon,
+  supabase: SupabaseIcon,
+  stt: STTIcon,
+  stripe: StripeIcon,
+  stagehand: StagehandIcon,
+  ssh: SshIcon,
+  sqs: SQSIcon,
+  spotify: SpotifyIcon,
+  smtp: SmtpIcon,
+  slack: SlackIcon,
+  shopify: ShopifyIcon,
+  sharepoint: MicrosoftSharepointIcon,
+  sftp: SftpIcon,
+  servicenow: ServiceNowIcon,
+  serper: SerperIcon,
+  sentry: SentryIcon,
+  sendgrid: SendgridIcon,
+  search: SearchIcon,
+  salesforce: SalesforceIcon,
+  s3: S3Icon,
+  resend: ResendIcon,
+  reddit: RedditIcon,
+  rds: RDSIcon,
+  qdrant: QdrantIcon,
+  posthog: PosthogIcon,
+  postgresql: PostgresIcon,
+  polymarket: PolymarketIcon,
+  pipedrive: PipedriveIcon,
+  pinecone: PineconeIcon,
+  perplexity: PerplexityIcon,
+  parallel_ai: ParallelIcon,
+  outlook: OutlookIcon,
+  openai: OpenAIIcon,
+  onedrive: MicrosoftOneDriveIcon,
+  notion: NotionIcon,
+  neo4j: Neo4jIcon,
+  mysql: MySQLIcon,
+  mongodb: MongoDBIcon,
+  mistral_parse: MistralIcon,
+  microsoft_teams: MicrosoftTeamsIcon,
+  microsoft_planner: MicrosoftPlannerIcon,
+  microsoft_excel: MicrosoftExcelIcon,
+  memory: BrainIcon,
+  mem0: Mem0Icon,
+  mailgun: MailgunIcon,
+  mailchimp: MailchimpIcon,
+  linkup: LinkupIcon,
+  linkedin: LinkedInIcon,
+  linear: LinearIcon,
+  knowledge: PackageSearchIcon,
+  kalshi: KalshiIcon,
+  jira: JiraIcon,
+  jina: JinaAIIcon,
+  intercom: IntercomIcon,
+  incidentio: IncidentioIcon,
+  image_generator: ImageIcon,
+  hunter: HunterIOIcon,
+  huggingface: HuggingFaceIcon,
+  hubspot: HubspotIcon,
+  grafana: GrafanaIcon,
+  google_vault: GoogleVaultIcon,
+  google_slides: GoogleSlidesIcon,
+  google_sheets: GoogleSheetsIcon,
+  google_groups: GoogleGroupsIcon,
+  google_forms: GoogleFormsIcon,
+  google_drive: GoogleDriveIcon,
+  google_docs: GoogleDocsIcon,
+  google_calendar: GoogleCalendarIcon,
+  google_search: GoogleIcon,
+  gmail: GmailIcon,
+  gitlab: GitLabIcon,
+  github: GithubIcon,
+  firecrawl: FirecrawlIcon,
+  file: DocumentIcon,
+  exa: ExaAIIcon,
+  elevenlabs: ElevenLabsIcon,
+  elasticsearch: ElasticsearchIcon,
+  dynamodb: DynamoDBIcon,
+  duckduckgo: DuckDuckGoIcon,
+  dropbox: DropboxIcon,
+  discord: DiscordIcon,
+  datadog: DatadogIcon,
+  cursor: CursorIcon,
+  confluence: ConfluenceIcon,
+  clay: ClayIcon,
+  calendly: CalendlyIcon,
+  browser_use: BrowserUseIcon,
+  asana: AsanaIcon,
+  arxiv: ArxivIcon,
+  apollo: ApolloIcon,
+  apify: ApifyIcon,
+  airtable: AirtableIcon,
+  ahrefs: AhrefsIcon,
 }

apps/docs/content/docs/de/blocks/webhook.mdx

@@ -1,89 +0,0 @@
----
-title: Webhook
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-import { Image } from '@/components/ui/image'
-
-Der Webhook-Block sendet HTTP-POST-Anfragen an externe Webhook-Endpunkte mit automatischen Webhook-Headern und optionaler HMAC-Signierung.
-
-<div className="flex justify-center">
-  <Image
-    src="/static/blocks/webhook.png"
-    alt="Webhook-Block"
-    width={500}
-    height={400}
-    className="my-6"
-  />
-</div>
-
-## Konfiguration
-
-### Webhook-URL
-
-Der Ziel-Endpunkt für Ihre Webhook-Anfrage. Unterstützt sowohl statische URLs als auch dynamische Werte aus anderen Blöcken.
-
-### Payload
-
-JSON-Daten, die im Anfrage-Body gesendet werden. Verwenden Sie den KI-Zauberstab, um Payloads zu generieren oder auf Workflow-Variablen zu verweisen:
-
-```json
-{
-  "event": "workflow.completed",
-  "data": {
-    "result": "<agent.content>",
-    "timestamp": "<function.result>"
-  }
-}
-```
-
-### Signierungsgeheimnis
-
-Optionales Geheimnis für die HMAC-SHA256-Payload-Signierung. Wenn angegeben, wird ein `X-Webhook-Signature`Header hinzugefügt:
-
-```
-X-Webhook-Signature: t=1704067200000,v1=5d41402abc4b2a76b9719d911017c592...
-```
-
-Um Signaturen zu verifizieren, berechnen Sie `HMAC-SHA256(secret, "${timestamp}.${body}")` und vergleichen Sie mit dem `v1`Wert.
-
-### Zusätzliche Header
-
-Benutzerdefinierte Schlüssel-Wert-Header, die in die Anfrage aufgenommen werden. Diese überschreiben alle automatischen Header mit demselben Namen.
-
-## Automatische Header
-
-Jede Anfrage enthält automatisch diese Header:
-
-| Header | Beschreibung |
-|--------|-------------|
-| `Content-Type` | `application/json` |
-| `X-Webhook-Timestamp` | Unix-Zeitstempel in Millisekunden |
-| `X-Delivery-ID` | Eindeutige UUID für diese Zustellung |
-| `Idempotency-Key` | Identisch mit `X-Delivery-ID` zur Deduplizierung |
-
-## Ausgaben
-
-| Ausgabe | Typ | Beschreibung |
-|--------|------|-------------|
-| `data` | json | Antwort-Body vom Endpunkt |
-| `status` | number | HTTP-Statuscode |
-| `headers` | object | Antwort-Header |
-
-## Beispiel-Anwendungsfälle
-
-**Externe Dienste benachrichtigen** - Workflow-Ergebnisse an Slack, Discord oder benutzerdefinierte Endpunkte senden
-
-```
-Agent → Function (format) → Webhook (notify)
-```
-
-**Externe Workflows auslösen** - Prozesse in anderen Systemen starten, wenn Bedingungen erfüllt sind
-
-```
-Condition (check) → Webhook (trigger) → Response
-```
-
-<Callout>
-Der Webhook-Block verwendet immer POST. Für andere HTTP-Methoden oder mehr Kontrolle verwenden Sie den [API-Block](/blocks/api).
-</Callout>

apps/docs/content/docs/de/enterprise/index.mdx

@@ -1,77 +0,0 @@
----
-title: Enterprise
-description: Enterprise-Funktionen für Organisationen mit erweiterten
-  Sicherheits- und Compliance-Anforderungen
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-
-Sim Studio Enterprise bietet erweiterte Funktionen für Organisationen mit erhöhten Sicherheits-, Compliance- und Verwaltungsanforderungen.
-
----
-
-## Bring Your Own Key (BYOK)
-
-Verwenden Sie Ihre eigenen API-Schlüssel für KI-Modellanbieter anstelle der gehosteten Schlüssel von Sim Studio.
-
-### Unterstützte Anbieter
-
-| Anbieter | Verwendung |
-|----------|-------|
-| OpenAI | Knowledge Base-Embeddings, Agent-Block |
-| Anthropic | Agent-Block |
-| Google | Agent-Block |
-| Mistral | Knowledge Base OCR |
-
-### Einrichtung
-
-1. Navigieren Sie zu **Einstellungen** → **BYOK** in Ihrem Workspace
-2. Klicken Sie auf **Schlüssel hinzufügen** für Ihren Anbieter
-3. Geben Sie Ihren API-Schlüssel ein und speichern Sie
-
-<Callout type="warn">
-  BYOK-Schlüssel werden verschlüsselt gespeichert. Nur Organisationsadministratoren und -inhaber können Schlüssel verwalten.
-</Callout>
-
-Wenn konfiguriert, verwenden Workflows Ihren Schlüssel anstelle der gehosteten Schlüssel von Sim Studio. Bei Entfernung wechseln Workflows automatisch zu den gehosteten Schlüsseln zurück.
-
----
-
-## Single Sign-On (SSO)
-
-Enterprise-Authentifizierung mit SAML 2.0- und OIDC-Unterstützung für zentralisiertes Identitätsmanagement.
-
-### Unterstützte Anbieter
-
-- Okta
-- Azure AD / Entra ID
-- Google Workspace
-- OneLogin
-- Jeder SAML 2.0- oder OIDC-Anbieter
-
-### Einrichtung
-
-1. Navigieren Sie zu **Einstellungen** → **SSO** in Ihrem Workspace
-2. Wählen Sie Ihren Identitätsanbieter
-3. Konfigurieren Sie die Verbindung mithilfe der Metadaten Ihres IdP
-4. Aktivieren Sie SSO für Ihre Organisation
-
-<Callout type="info">
-  Sobald SSO aktiviert ist, authentifizieren sich Teammitglieder über Ihren Identitätsanbieter anstelle von E-Mail/Passwort.
-</Callout>
-
----
-
-## Self-Hosted
-
-Für selbst gehostete Bereitstellungen können Enterprise-Funktionen über Umgebungsvariablen aktiviert werden:
-
-| Variable | Beschreibung |
-|----------|-------------|
-| `SSO_ENABLED`, `NEXT_PUBLIC_SSO_ENABLED` | Single Sign-On mit SAML/OIDC |
-| `CREDENTIAL_SETS_ENABLED`, `NEXT_PUBLIC_CREDENTIAL_SETS_ENABLED` | Polling-Gruppen für E-Mail-Trigger |
-| `DISABLE_INVITATIONS`, `NEXT_PUBLIC_DISABLE_INVITATIONS` | Workspace-/Organisations-Einladungen global deaktivieren |
-
-<Callout type="warn">
-  BYOK ist nur im gehosteten Sim Studio verfügbar. Selbst gehostete Deployments konfigurieren AI-Provider-Schlüssel direkt über Umgebungsvariablen.
-</Callout>

apps/docs/content/docs/de/execution/costs.mdx

@@ -49,40 +49,40 @@ Die Modellaufschlüsselung zeigt:
 
 <Tabs items={['Hosted Models', 'Bring Your Own API Key']}>
   <Tab>
-    **Hosted Models** - Sim bietet API-Schlüssel mit einem 1,4-fachen Preismultiplikator für Agent-Blöcke:
+    **Gehostete Modelle** - Sim stellt API-Schlüssel mit einem 2,5-fachen Preismultiplikator bereit:
 
     **OpenAI**
-    | Modell | Basispreis (Eingabe/Ausgabe) | Hosted-Preis (Eingabe/Ausgabe) |
+    | Modell | Basispreis (Eingabe/Ausgabe) | Gehosteter Preis (Eingabe/Ausgabe) |
     |-------|---------------------------|----------------------------|
-    | GPT-5.1 | $1.25 / $10.00 | $1.75 / $14.00 |
-    | GPT-5 | $1.25 / $10.00 | $1.75 / $14.00 |
-    | GPT-5 Mini | $0.25 / $2.00 | $0.35 / $2.80 |
-    | GPT-5 Nano | $0.05 / $0.40 | $0.07 / $0.56 |
-    | GPT-4o | $2.50 / $10.00 | $3.50 / $14.00 |
-    | GPT-4.1 | $2.00 / $8.00 | $2.80 / $11.20 |
-    | GPT-4.1 Mini | $0.40 / $1.60 | $0.56 / $2.24 |
-    | GPT-4.1 Nano | $0.10 / $0.40 | $0.14 / $0.56 |
-    | o1 | $15.00 / $60.00 | $21.00 / $84.00 |
-    | o3 | $2.00 / $8.00 | $2.80 / $11.20 |
-    | o4 Mini | $1.10 / $4.40 | $1.54 / $6.16 |
+    | GPT-5.1 | $1,25 / $10,00 | $3,13 / $25,00 |
+    | GPT-5 | $1,25 / $10,00 | $3,13 / $25,00 |
+    | GPT-5 Mini | $0,25 / $2,00 | $0,63 / $5,00 |
+    | GPT-5 Nano | $0,05 / $0,40 | $0,13 / $1,00 |
+    | GPT-4o | $2,50 / $10,00 | $6,25 / $25,00 |
+    | GPT-4.1 | $2,00 / $8,00 | $5,00 / $20,00 |
+    | GPT-4.1 Mini | $0,40 / $1,60 | $1,00 / $4,00 |
+    | GPT-4.1 Nano | $0,10 / $0,40 | $0,25 / $1,00 |
+    | o1 | $15,00 / $60,00 | $37,50 / $150,00 |
+    | o3 | $2,00 / $8,00 | $5,00 / $20,00 |
+    | o4 Mini | $1,10 / $4,40 | $2,75 / $11,00 |
 
     **Anthropic**
-    | Modell | Basispreis (Eingabe/Ausgabe) | Hosted-Preis (Eingabe/Ausgabe) |
+    | Modell | Basispreis (Eingabe/Ausgabe) | Gehosteter Preis (Eingabe/Ausgabe) |
     |-------|---------------------------|----------------------------|
-    | Claude Opus 4.5 | $5.00 / $25.00 | $7.00 / $35.00 |
-    | Claude Opus 4.1 | $15.00 / $75.00 | $21.00 / $105.00 |
-    | Claude Sonnet 4.5 | $3.00 / $15.00 | $4.20 / $21.00 |
-    | Claude Sonnet 4.0 | $3.00 / $15.00 | $4.20 / $21.00 |
-    | Claude Haiku 4.5 | $1.00 / $5.00 | $1.40 / $7.00 |
+    | Claude Opus 4.5 | $5,00 / $25,00 | $12,50 / $62,50 |
+    | Claude Opus 4.1 | $15,00 / $75,00 | $37,50 / $187,50 |
+    | Claude Sonnet 4.5 | $3,00 / $15,00 | $7,50 / $37,50 |
+    | Claude Sonnet 4.0 | $3,00 / $15,00 | $7,50 / $37,50 |
+    | Claude Haiku 4.5 | $1,00 / $5,00 | $2,50 / $12,50 |
 
     **Google**
-    | Modell | Basispreis (Eingabe/Ausgabe) | Hosted-Preis (Eingabe/Ausgabe) |
+    | Modell | Basispreis (Eingabe/Ausgabe) | Gehosteter Preis (Eingabe/Ausgabe) |
     |-------|---------------------------|----------------------------|
-    | Gemini 3 Pro Preview | $2.00 / $12.00 | $2.80 / $16.80 |
-    | Gemini 2.5 Pro | $1.25 / $10.00 | $1.75 / $14.00 |
-    | Gemini 2.5 Flash | $0.30 / $2.50 | $0.42 / $3.50 |
+    | Gemini 3 Pro Preview | $2,00 / $12,00 | $5,00 / $30,00 |
+    | Gemini 2.5 Pro | $0,15 / $0,60 | $0,38 / $1,50 |
+    | Gemini 2.5 Flash | $0,15 / $0,60 | $0,38 / $1,50 |
 
-    *Der 1,4-fache Multiplikator deckt Infrastruktur- und API-Verwaltungskosten ab.*
+    *Der 2,5-fache Multiplikator deckt Infrastruktur- und API-Verwaltungskosten ab.*
   </Tab>
 
   <Tab>
@@ -105,32 +105,28 @@ Die Modellaufschlüsselung zeigt:
   Die angezeigten Preise entsprechen den Tarifen vom 10. September 2025. Überprüfen Sie die Dokumentation der Anbieter für aktuelle Preise.
 </Callout>
 
-## Bring Your Own Key (BYOK)
-
-Sie können Ihre eigenen API-Schlüssel für gehostete Modelle (OpenAI, Anthropic, Google, Mistral) unter **Einstellungen → BYOK** verwenden, um Basispreise zu zahlen. Schlüssel werden verschlüsselt und gelten arbeitsbereichsweit.
-
 ## Strategien zur Kostenoptimierung
 
-- **Modellauswahl**: Wählen Sie Modelle basierend auf der Aufgabenkomplexität. Einfache Aufgaben können GPT-4.1-nano verwenden, während komplexes Reasoning o1 oder Claude Opus erfordern könnte.
-- **Prompt Engineering**: Gut strukturierte, prägnante Prompts reduzieren den Token-Verbrauch ohne Qualitätsverlust.
+- **Modellauswahl**: Wählen Sie Modelle basierend auf der Komplexität der Aufgabe. Einfache Aufgaben können GPT-4.1-nano verwenden, während komplexes Denken möglicherweise o1 oder Claude Opus erfordert.
+- **Prompt-Engineering**: Gut strukturierte, präzise Prompts reduzieren den Token-Verbrauch ohne Qualitätseinbußen.
 - **Lokale Modelle**: Verwenden Sie Ollama oder VLLM für unkritische Aufgaben, um API-Kosten vollständig zu eliminieren.
-- **Caching und Wiederverwendung**: Speichern Sie häufig verwendete Ergebnisse in Variablen oder Dateien, um wiederholte AI-Modellaufrufe zu vermeiden.
-- **Batch-Verarbeitung**: Verarbeiten Sie mehrere Elemente in einer einzigen AI-Anfrage, anstatt einzelne Aufrufe zu tätigen.
+- **Caching und Wiederverwendung**: Speichern Sie häufig verwendete Ergebnisse in Variablen oder Dateien, um wiederholte KI-Modellaufrufe zu vermeiden.
+- **Batch-Verarbeitung**: Verarbeiten Sie mehrere Elemente in einer einzigen KI-Anfrage anstatt einzelne Aufrufe zu tätigen.
 
 ## Nutzungsüberwachung
 
 Überwachen Sie Ihre Nutzung und Abrechnung unter Einstellungen → Abonnement:
 
-- **Aktuelle Nutzung**: Echtzeit-Nutzung und Kosten für den aktuellen Zeitraum
-- **Nutzungslimits**: Plan-Limits mit visuellen Fortschrittsindikatoren
+- **Aktuelle Nutzung**: Echtzeit-Nutzung und -Kosten für den aktuellen Zeitraum
+- **Nutzungslimits**: Plangrenzen mit visuellen Fortschrittsanzeigen
 - **Abrechnungsdetails**: Prognostizierte Gebühren und Mindestverpflichtungen
-- **Plan-Verwaltung**: Upgrade-Optionen und Abrechnungsverlauf
+- **Planverwaltung**: Upgrade-Optionen und Abrechnungsverlauf
 
-### Programmatisches Nutzungs-Tracking
+### Programmatische Nutzungsverfolgung
 
 Sie können Ihre aktuelle Nutzung und Limits programmatisch über die API abfragen:
 
-**Endpoint:**
+**Endpunkt:**
 
 ```text
 GET /api/users/me/usage-limits
@@ -176,69 +172,69 @@ curl -X GET -H "X-API-Key: YOUR_API_KEY" -H "Content-Type: application/json" htt
 ```
 
 **Rate-Limit-Felder:**
-- `requestsPerMinute`: Dauerhaftes Rate-Limit (Tokens werden mit dieser Rate aufgefüllt)
-- `maxBurst`: Maximale Tokens, die Sie akkumulieren können (Burst-Kapazität)
-- `remaining`: Aktuell verfügbare Tokens (kann bis zu `maxBurst` betragen)
+- `requestsPerMinute`: Dauerhafte Rate-Begrenzung (Tokens werden mit dieser Rate aufgefüllt)
+- `maxBurst`: Maximale Tokens, die Sie ansammeln können (Burst-Kapazität)
+- `remaining`: Aktuell verfügbare Tokens (können bis zu `maxBurst` sein)
 
 **Antwortfelder:**
-- `currentPeriodCost` spiegelt die Nutzung im aktuellen Abrechnungszeitraum wider
-- `limit` wird aus individuellen Limits (Free/Pro) oder gepoolten Organisationslimits (Team/Enterprise) abgeleitet
-- `plan` ist der Plan mit der höchsten Priorität, der Ihrem Benutzer zugeordnet ist
+- `currentPeriodCost` spiegelt die Nutzung in der aktuellen Abrechnungsperiode wider
+- `limit` wird von individuellen Limits (Free/Pro) oder gepoolten Organisationslimits (Team/Enterprise) abgeleitet
+- `plan` ist der aktive Plan mit der höchsten Priorität, der mit Ihrem Benutzer verknüpft ist
 
 ## Plan-Limits
 
-Verschiedene Abonnement-Pläne haben unterschiedliche Nutzungslimits:
+Verschiedene Abonnementpläne haben unterschiedliche Nutzungslimits:
 
-| Plan | Monatliches Nutzungslimit | Ratenlimits (pro Minute) |
+| Plan | Monatliches Nutzungslimit | Rate-Limits (pro Minute) |
 |------|-------------------|-------------------------|
-| **Free** | 20 $ | 5 sync, 10 async |
-| **Pro** | 100 $ | 10 sync, 50 async |
-| **Team** | 500 $ (gemeinsam) | 50 sync, 100 async |
+| **Free** | $10 | 5 sync, 10 async |
+| **Pro** | $100 | 10 sync, 50 async |
+| **Team** | $500 (gepoolt) | 50 sync, 100 async |
 | **Enterprise** | Individuell | Individuell |
 
 ## Abrechnungsmodell
 
-Sim verwendet ein **Basis-Abonnement + Mehrverbrauch**-Abrechnungsmodell:
+Sim verwendet ein **Basisabonnement + Mehrverbrauch**-Abrechnungsmodell:
 
-### So funktioniert es
+### Wie es funktioniert
 
-**Pro-Plan (20 $/Monat):**
-- Monatsabonnement beinhaltet 20 $ Nutzung
-- Nutzung unter 20 $ → Keine zusätzlichen Gebühren
-- Nutzung über 20 $ → Mehrverbrauch am Monatsende zahlen
-- Beispiel: 35 $ Nutzung = 20 $ (Abonnement) + 15 $ (Mehrverbrauch)
+**Pro-Plan ($20/Monat):**
+- Monatliches Abonnement beinhaltet $20 Nutzung
+- Nutzung unter $20 → Keine zusätzlichen Kosten
+- Nutzung über $20 → Zahlen Sie den Mehrverbrauch am Monatsende
+- Beispiel: $35 Nutzung = $20 (Abonnement) + $15 (Mehrverbrauch)
 
-**Team-Plan (40 $/Platz/Monat):**
-- Gemeinsame Nutzung über alle Teammitglieder
-- Mehrverbrauch wird aus der gesamten Team-Nutzung berechnet
+**Team-Plan ($40/Benutzer/Monat):**
+- Gepoolte Nutzung für alle Teammitglieder
+- Mehrverbrauch wird aus der Gesamtnutzung des Teams berechnet
 - Organisationsinhaber erhält eine Rechnung
 
 **Enterprise-Pläne:**
-- Fester Monatspreis, kein Mehrverbrauch
+- Fester monatlicher Preis, kein Mehrverbrauch
 - Individuelle Nutzungslimits gemäß Vereinbarung
 
 ### Schwellenwert-Abrechnung
 
-Wenn der nicht abgerechnete Mehrverbrauch 50 $ erreicht, rechnet Sim automatisch den gesamten nicht abgerechneten Betrag ab.
+Wenn der nicht abgerechnete Mehrverbrauch $50 erreicht, berechnet Sim automatisch den gesamten nicht abgerechneten Betrag.
 
 **Beispiel:**
-- Tag 10: 70 $ Mehrverbrauch → 70 $ sofort abrechnen
-- Tag 15: Zusätzliche 35 $ Nutzung (105 $ gesamt) → Bereits abgerechnet, keine Aktion
-- Tag 20: Weitere 50 $ Nutzung (155 $ gesamt, 85 $ nicht abgerechnet) → 85 $ sofort abrechnen
+- Tag 10: $70 Mehrverbrauch → Sofortige Abrechnung von $70
+- Tag 15: Zusätzliche $35 Nutzung ($105 insgesamt) → Bereits abgerechnet, keine Aktion
+- Tag 20: Weitere $50 Nutzung ($155 insgesamt, $85 nicht abgerechnet) → Sofortige Abrechnung von $85
 
-Dies verteilt große Mehrverbrauchsgebühren über den Monat, anstatt einer großen Rechnung am Periodenende.
+Dies verteilt große Überziehungsgebühren über den Monat, anstatt eine große Rechnung am Ende des Abrechnungszeitraums zu erhalten.
 
 ## Best Practices für Kostenmanagement
 
 1. **Regelmäßig überwachen**: Überprüfen Sie Ihr Nutzungs-Dashboard häufig, um Überraschungen zu vermeiden
-2. **Budgets festlegen**: Nutzen Sie Plan-Limits als Leitplanken für Ihre Ausgaben
+2. **Budgets festlegen**: Nutzen Sie Planlimits als Leitplanken für Ihre Ausgaben
 3. **Workflows optimieren**: Überprüfen Sie kostenintensive Ausführungen und optimieren Sie Prompts oder Modellauswahl
 4. **Passende Modelle verwenden**: Passen Sie die Modellkomplexität an die Aufgabenanforderungen an
-5. **Ähnliche Aufgaben bündeln**: Kombinieren Sie mehrere Anfragen, wenn möglich, um Overhead zu reduzieren
+5. **Ähnliche Aufgaben bündeln**: Kombinieren Sie wenn möglich mehrere Anfragen, um den Overhead zu reduzieren
 
 ## Nächste Schritte
 
 - Überprüfen Sie Ihre aktuelle Nutzung unter [Einstellungen → Abonnement](https://sim.ai/settings/subscription)
 - Erfahren Sie mehr über [Protokollierung](/execution/logging), um Ausführungsdetails zu verfolgen
-- Entdecken Sie die [externe API](/execution/api) für programmatische Kostenüberwachung
+- Erkunden Sie die [Externe API](/execution/api) für programmatische Kostenüberwachung
 - Sehen Sie sich [Workflow-Optimierungstechniken](/blocks) an, um Kosten zu reduzieren

apps/docs/content/docs/de/keyboard-shortcuts/index.mdx

@@ -1,63 +0,0 @@
----
-title: Tastaturkürzel
-description: Meistern Sie die Workflow-Arbeitsfläche mit Tastaturkürzeln und Maussteuerung
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-
-Beschleunigen Sie die Erstellung Ihrer Workflows mit diesen Tastaturkürzeln und Maussteuerungen. Alle Tastenkombinationen funktionieren, wenn die Arbeitsfläche fokussiert ist (nicht beim Tippen in einem Eingabefeld).
-
-<Callout type="info">
-  **Mod** bezieht sich auf `Cmd` unter macOS und `Ctrl` unter Windows/Linux.
-</Callout>
-
-## Arbeitsflächen-Steuerung
-
-### Maussteuerung
-
-| Aktion | Steuerung |
-|--------|---------|
-| Arbeitsfläche verschieben | Linksziehen auf leerer Fläche |
-| Arbeitsfläche verschieben | Scrollen oder Trackpad |
-| Mehrere Blöcke auswählen | Rechtsziehen zum Aufziehen eines Auswahlrahmens |
-| Block ziehen | Linksziehen auf Block-Kopfzeile |
-| Zur Auswahl hinzufügen | `Mod` + Klick auf Blöcke |
-
-### Workflow-Aktionen
-
-| Tastenkombination | Aktion |
-|----------|--------|
-| `Mod` + `Enter` | Workflow ausführen (oder abbrechen, falls aktiv) |
-| `Mod` + `Z` | Rückgängig |
-| `Mod` + `Shift` + `Z` | Wiederholen |
-| `Mod` + `C` | Ausgewählte Blöcke kopieren |
-| `Mod` + `V` | Blöcke einfügen |
-| `Delete` oder `Backspace` | Ausgewählte Blöcke oder Verbindungen löschen |
-| `Shift` + `L` | Arbeitsfläche automatisch anordnen |
-
-## Panel-Navigation
-
-Diese Tastenkombinationen wechseln zwischen den Panel-Tabs auf der rechten Seite der Arbeitsfläche.
-
-| Tastenkombination | Aktion |
-|----------|--------|
-| `C` | Copilot-Tab fokussieren |
-| `T` | Toolbar-Tab fokussieren |
-| `E` | Editor-Tab fokussieren |
-| `Mod` + `F` | Toolbar-Suche fokussieren |
-
-## Globale Navigation
-
-| Tastenkombination | Aktion |
-|----------|--------|
-| `Mod` + `K` | Suche öffnen |
-| `Mod` + `Shift` + `A` | Neuen Agenten-Workflow hinzufügen |
-| `Mod` + `Y` | Zu Vorlagen gehen |
-| `Mod` + `L` | Zu Logs gehen |
-
-## Dienstprogramm
-
-| Tastenkombination | Aktion |
-|----------|--------|
-| `Mod` + `D` | Terminal-Konsole leeren |
-| `Mod` + `E` | Benachrichtigungen löschen |

apps/docs/content/docs/de/knowledgebase/index.mdx

@@ -35,87 +35,81 @@ Sobald Ihre Dokumente verarbeitet sind, können Sie die einzelnen Chunks anzeige
 <Image src="/static/knowledgebase/knowledgebase.png" alt="Dokumentchunk-Ansicht mit verarbeiteten Inhalten" width={800} height={500} />
 
 ### Chunk-Konfiguration
+- **Standardgröße der Chunks**: 1.024 Zeichen
+- **Konfigurierbarer Bereich**: 100-4.000 Zeichen pro Chunk
+- **Intelligente Überlappung**: Standardmäßig 200 Zeichen zur Kontexterhaltung
+- **Hierarchische Aufteilung**: Respektiert Dokumentstruktur (Abschnitte, Absätze, Sätze)
 
-Beim Erstellen einer Wissensdatenbank können Sie konfigurieren, wie Dokumente in Chunks aufgeteilt werden:
-
-| Einstellung | Einheit | Standard | Bereich | Beschreibung |
-|---------|------|---------|-------|-------------|
-| **Maximale Chunk-Größe** | Tokens | 1.024 | 100-4.000 | Maximale Größe jedes Chunks (1 Token ≈ 4 Zeichen) |
-| **Minimale Chunk-Größe** | Zeichen | 1 | 1-2.000 | Minimale Chunk-Größe, um winzige Fragmente zu vermeiden |
-| **Überlappung** | Zeichen | 200 | 0-500 | Kontextüberlappung zwischen aufeinanderfolgenden Chunks |
-
-- **Hierarchische Aufteilung**: Berücksichtigt die Dokumentstruktur (Abschnitte, Absätze, Sätze)
-
-### Bearbeitungsmöglichkeiten
+### Bearbeitungsfunktionen
 - **Chunk-Inhalt bearbeiten**: Textinhalt einzelner Chunks ändern
-- **Chunk-Grenzen anpassen**: Chunks nach Bedarf zusammenführen oder aufteilen
+- **Chunk-Grenzen anpassen**: Chunks bei Bedarf zusammenführen oder teilen
 - **Metadaten hinzufügen**: Chunks mit zusätzlichem Kontext anreichern
-- **Massenoperationen**: Mehrere Chunks effizient verwalten
+- **Massenoperationen**: Effiziente Verwaltung mehrerer Chunks
 
 ## Erweiterte PDF-Verarbeitung
 
 Für PDF-Dokumente bietet Sim erweiterte Verarbeitungsfunktionen:
 
 ### OCR-Unterstützung
-Wenn mit Azure oder [Mistral OCR](https://docs.mistral.ai/ocr/) konfiguriert:
+Bei Konfiguration mit Azure oder [Mistral OCR](https://docs.mistral.ai/ocr/):
 - **Verarbeitung gescannter Dokumente**: Text aus bildbasierten PDFs extrahieren
-- **Verarbeitung gemischter Inhalte**: PDFs mit Text und Bildern verarbeiten
+- **Umgang mit gemischten Inhalten**: Verarbeitung von PDFs mit Text und Bildern
 - **Hohe Genauigkeit**: Fortschrittliche KI-Modelle gewährleisten präzise Textextraktion
 
-## Verwendung des Knowledge-Blocks in Workflows
+## Verwendung des Wissensblocks in Workflows
 
-Sobald Ihre Dokumente verarbeitet sind, können Sie sie in Ihren KI-Workflows über den Knowledge-Block verwenden. Dies ermöglicht Retrieval-Augmented Generation (RAG), wodurch Ihre KI-Agenten auf Ihre Dokumentinhalte zugreifen und darüber nachdenken können, um genauere, kontextbezogene Antworten zu liefern.
+Sobald Ihre Dokumente verarbeitet sind, können Sie sie in Ihren KI-Workflows über den Wissensblock nutzen. Dies ermöglicht Retrieval-Augmented Generation (RAG), wodurch Ihre KI-Agenten auf Ihre Dokumentinhalte zugreifen und darüber nachdenken können, um genauere, kontextbezogene Antworten zu liefern.
 
-<Image src="/static/knowledgebase/knowledgebase-2.png" alt="Verwendung des Knowledge-Blocks in Workflows" width={800} height={500} />
+<Image src="/static/knowledgebase/knowledgebase-2.png" alt="Verwendung des Wissensblocks in Workflows" width={800} height={500} />
 
-### Knowledge-Block-Funktionen
-- **Semantische Suche**: Relevante Inhalte mithilfe natürlichsprachlicher Abfragen finden
-- **Kontextintegration**: Relevante Chunks automatisch in Agenten-Prompts einbinden
-- **Dynamisches Abrufen**: Suche erfolgt in Echtzeit während der Workflow-Ausführung
-- **Relevanz-Bewertung**: Ergebnisse nach semantischer Ähnlichkeit sortiert
+### Funktionen des Wissensblocks
+- **Semantische Suche**: Relevante Inhalte mit natürlichsprachlichen Abfragen finden
+- **Kontextintegration**: Automatisches Einbinden relevanter Chunks in Agenten-Prompts
+- **Dynamischer Abruf**: Suche erfolgt in Echtzeit während der Workflow-Ausführung
+- **Relevanzbewertung**: Ergebnisse nach semantischer Ähnlichkeit geordnet
 
 ### Integrationsoptionen
-- **System-Prompts**: Stellen Sie Ihren KI-Agenten Kontext bereit
-- **Dynamischer Kontext**: Suchen und fügen Sie relevante Informationen während Konversationen hinzu
-- **Multi-Dokument-Suche**: Durchsuchen Sie Ihre gesamte Wissensdatenbank
-- **Gefilterte Suche**: Kombinieren Sie mit Tags für präzises Abrufen von Inhalten
+- **System-Prompts**: Kontext für Ihre KI-Agenten bereitstellen
+- **Dynamischer Kontext**: Suche und Einbindung relevanter Informationen während Gesprächen
+- **Dokumentübergreifende Suche**: Abfrage über Ihre gesamte Wissensdatenbank
+- **Gefilterte Suche**: Kombination mit Tags für präzisen Inhaltsabruf
 
-## Vektor-Suchtechnologie
+## Vektorsuchtechnologie
 
 Sim verwendet Vektorsuche, die von [pgvector](https://github.com/pgvector/pgvector) unterstützt wird, um die Bedeutung und den Kontext Ihrer Inhalte zu verstehen:
 
 ### Semantisches Verständnis
 - **Kontextuelle Suche**: Findet relevante Inhalte, auch wenn exakte Schlüsselwörter nicht übereinstimmen
-- **Konzeptbasiertes Abrufen**: Versteht Beziehungen zwischen Ideen
+- **Konzeptbasierte Abfrage**: Versteht Beziehungen zwischen Ideen
 - **Mehrsprachige Unterstützung**: Funktioniert über verschiedene Sprachen hinweg
 - **Synonymerkennung**: Findet verwandte Begriffe und Konzepte
 
 ### Suchfunktionen
-- **Natürlichsprachige Abfragen**: Stellen Sie Fragen in einfachem Deutsch
+- **Natürlichsprachige Abfragen**: Stellen Sie Fragen in natürlicher Sprache
 - **Ähnlichkeitssuche**: Finden Sie konzeptionell ähnliche Inhalte
-- **Hybride Suche**: Kombiniert Vektor- und traditionelle Schlüsselwortsuche
-- **Konfigurierbare Ergebnisse**: Steuern Sie die Anzahl und Relevanzschwelle der Ergebnisse
+- **Hybridsuche**: Kombiniert Vektor- und traditionelle Schlüsselwortsuche
+- **Konfigurierbare Ergebnisse**: Steuern Sie die Anzahl und den Relevanz-Schwellenwert der Ergebnisse
 
 ## Dokumentenverwaltung
 
 ### Organisationsfunktionen
-- **Massen-Upload**: Laden Sie mehrere Dateien gleichzeitig über die asynchrone API hoch
-- **Verarbeitungsstatus**: Echtzeit-Updates zur Dokumentenverarbeitung
-- **Suchen und filtern**: Finden Sie Dokumente schnell in großen Sammlungen
+- **Massenupload**: Laden Sie mehrere Dateien gleichzeitig über die asynchrone API hoch
+- **Verarbeitungsstatus**: Echtzeit-Updates zum Dokumentenverarbeitungsprozess
+- **Suchen und Filtern**: Finden Sie Dokumente schnell in großen Sammlungen
 - **Metadaten-Tracking**: Automatische Erfassung von Dateiinformationen und Verarbeitungsdetails
 
 ### Sicherheit und Datenschutz
 - **Sichere Speicherung**: Dokumente werden mit Sicherheit auf Unternehmensniveau gespeichert
 - **Zugriffskontrolle**: Workspace-basierte Berechtigungen
-- **Verarbeitungsisolierung**: Jeder Workspace hat isolierte Dokumentenverarbeitung
+- **Verarbeitungsisolierung**: Jeder Workspace hat eine isolierte Dokumentenverarbeitung
 - **Datenaufbewahrung**: Konfigurieren Sie Richtlinien zur Dokumentenaufbewahrung
 
 ## Erste Schritte
 
 1. **Navigieren Sie zu Ihrer Wissensdatenbank**: Zugriff über Ihre Workspace-Seitenleiste
-2. **Dokumente hochladen**: Ziehen und ablegen oder Dateien zum Hochladen auswählen
-3. **Verarbeitung überwachen**: Beobachten Sie, wie Dokumente verarbeitet und in Abschnitte unterteilt werden
-4. **Abschnitte erkunden**: Zeigen Sie die verarbeiteten Inhalte an und bearbeiten Sie sie
-5. **Zu Workflows hinzufügen**: Verwenden Sie den Knowledge-Block, um mit Ihren KI-Agenten zu integrieren
+2. **Dokumente hochladen**: Drag & Drop oder wählen Sie Dateien zum Hochladen aus
+3. **Verarbeitung überwachen**: Beobachten Sie, wie Dokumente verarbeitet und in Chunks aufgeteilt werden
+4. **Chunks erkunden**: Sehen und bearbeiten Sie die verarbeiteten Inhalte
+5. **Zu Workflows hinzufügen**: Verwenden Sie den Wissensblock, um ihn in Ihre KI-Agenten zu integrieren
 
-Die Wissensdatenbank verwandelt Ihre statischen Dokumente in eine intelligente, durchsuchbare Ressource, die Ihre KI-Workflows für fundiertere und kontextbezogene Antworten nutzen können.
+Die Wissensdatenbank verwandelt Ihre statischen Dokumente in eine intelligente, durchsuchbare Ressource, die Ihre KI-Workflows für fundiertere und kontextbezogenere Antworten nutzen können.

apps/docs/content/docs/de/mcp/deploy-workflows.mdx

@@ -1,108 +0,0 @@
----
-title: Workflows als MCP bereitstellen
-description: Stellen Sie Ihre Workflows als MCP-Tools für externe KI-Assistenten
-  und Anwendungen bereit
----
-
-import { Video } from '@/components/ui/video'
-import { Callout } from 'fumadocs-ui/components/callout'
-
-Stellen Sie Ihre Workflows als MCP-Tools bereit, um sie für externe KI-Assistenten wie Claude Desktop, Cursor und andere MCP-kompatible Clients zugänglich zu machen. Dies verwandelt Ihre Workflows in aufrufbare Tools, die von überall aus aufgerufen werden können.
-
-## MCP-Server erstellen und verwalten
-
-MCP-Server gruppieren Ihre Workflow-Tools zusammen. Erstellen und verwalten Sie sie in den Workspace-Einstellungen:
-
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp/mcp-server.mp4" width={700} height={450} />
-</div>
-
-1. Navigieren Sie zu **Einstellungen → Bereitgestellte MCPs**
-2. Klicken Sie auf **Server erstellen**
-3. Geben Sie einen Namen und eine optionale Beschreibung ein
-4. Kopieren Sie die Server-URL zur Verwendung in Ihren MCP-Clients
-5. Zeigen Sie alle zum Server hinzugefügten Tools an und verwalten Sie diese
-
-## Einen Workflow als Tool hinzufügen
-
-Sobald Ihr Workflow bereitgestellt ist, können Sie ihn als MCP-Tool verfügbar machen:
-
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp/mcp-deploy-tool.mp4" width={700} height={450} />
-</div>
-
-1. Öffnen Sie Ihren bereitgestellten Workflow
-2. Klicken Sie auf **Bereitstellen** und wechseln Sie zum Tab **MCP**
-3. Konfigurieren Sie den Tool-Namen und die Beschreibung
-4. Fügen Sie Beschreibungen für jeden Parameter hinzu (hilft der KI, Eingaben zu verstehen)
-5. Wählen Sie aus, zu welchen MCP-Servern es hinzugefügt werden soll
-
-<Callout type="info">
-Der Workflow muss bereitgestellt sein, bevor er als MCP-Tool hinzugefügt werden kann.
-</Callout>
-
-## Tool-Konfiguration
-
-### Tool-Name
-Verwenden Sie Kleinbuchstaben, Zahlen und Unterstriche. Der Name sollte beschreibend sein und den MCP-Namenskonventionen folgen (z. B. `search_documents`, `send_email`).
-
-### Beschreibung
-Schreiben Sie eine klare Beschreibung dessen, was das Tool tut. Dies hilft KI-Assistenten zu verstehen, wann das Tool verwendet werden soll.
-
-### Parameter
-Die Eingabeformatfelder deines Workflows werden zu Tool-Parametern. Füge jedem Parameter Beschreibungen hinzu, um KI-Assistenten zu helfen, korrekte Werte bereitzustellen.
-
-## MCP-Clients verbinden
-
-Verwende die Server-URL aus den Einstellungen, um externe Anwendungen zu verbinden:
-
-### Claude Desktop
-Füge dies zu deiner Claude Desktop-Konfiguration hinzu (`~/Library/Application Support/Claude/claude_desktop_config.json`):
-
-```json
-{
-  "mcpServers": {
-    "my-sim-workflows": {
-      "command": "npx",
-      "args": ["-y", "mcp-remote", "YOUR_SERVER_URL"]
-    }
-  }
-}
-```
-
-### Cursor
-Füge die Server-URL in den MCP-Einstellungen von Cursor mit demselben mcp-remote-Muster hinzu.
-
-<Callout type="warn">
-Füge deinen API-Key-Header (`X-API-Key`) für authentifizierten Zugriff hinzu, wenn du mcp-remote oder andere HTTP-basierte MCP-Transporte verwendest.
-</Callout>
-
-## Server-Verwaltung
-
-In der Server-Detailansicht unter **Einstellungen → Bereitgestellte MCPs** können Sie:
-
-- **Tools anzeigen**: Alle Workflows sehen, die einem Server hinzugefügt wurden
-- **URL kopieren**: Die Server-URL für MCP-Clients abrufen
-- **Workflows hinzufügen**: Weitere bereitgestellte Workflows als Tools hinzufügen
-- **Tools entfernen**: Workflows vom Server entfernen
-- **Server löschen**: Den gesamten Server und alle seine Tools entfernen
-
-## So funktioniert es
-
-Wenn ein MCP-Client dein Tool aufruft:
-
-1. Die Anfrage wird an deiner MCP-Server-URL empfangen
-2. Sim validiert die Anfrage und ordnet Parameter den Workflow-Eingaben zu
-3. Der bereitgestellte Workflow wird mit den angegebenen Eingaben ausgeführt
-4. Die Ergebnisse werden an den MCP-Client zurückgegeben
-
-Workflows werden mit derselben Bereitstellungsversion wie API-Aufrufe ausgeführt, was konsistentes Verhalten gewährleistet.
-
-## Berechtigungsanforderungen
-
-| Aktion | Erforderliche Berechtigung |
-|--------|-------------------|
-| MCP-Server erstellen | **Admin** |
-| Workflows zu Servern hinzufügen | **Write** oder **Admin** |
-| MCP-Server anzeigen | **Read**, **Write** oder **Admin** |
-| MCP-Server löschen | **Admin** |

apps/docs/content/docs/de/mcp/index.mdx

@@ -1,10 +1,8 @@
 ---
-title: MCP-Tools verwenden
-description: Externe Tools und Dienste über das Model Context Protocol verbinden
+title: MCP (Model Context Protocol)
 ---
 
 import { Image } from '@/components/ui/image'
-import { Video } from '@/components/ui/video'
 import { Callout } from 'fumadocs-ui/components/callout'
 
 Das Model Context Protocol ([MCP](https://modelcontextprotocol.com/)) ermöglicht es Ihnen, externe Tools und Dienste über ein standardisiertes Protokoll zu verbinden, wodurch Sie APIs und Dienste direkt in Ihre Workflows integrieren können. Mit MCP können Sie die Fähigkeiten von Sim erweitern, indem Sie benutzerdefinierte Integrationen hinzufügen, die nahtlos mit Ihren Agenten und Workflows zusammenarbeiten.
@@ -22,12 +20,18 @@ MCP ist ein offener Standard, der es KI-Assistenten ermöglicht, sich sicher mit
 
 MCP-Server stellen Sammlungen von Tools bereit, die Ihre Agenten nutzen können. Konfigurieren Sie diese in den Workspace-Einstellungen:
 
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp/settings-mcp-tools.mp4" width={700} height={450} />
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/mcp-1.png"
+    alt="Konfiguration eines MCP-Servers in den Einstellungen"
+    width={700}
+    height={450}
+    className="my-6"
+  />
 </div>
 
 1. Navigieren Sie zu Ihren Workspace-Einstellungen
-2. Gehen Sie zum Abschnitt **Bereitgestellte MCPs**
+2. Gehen Sie zum Abschnitt **MCP-Server**
 3. Klicken Sie auf **MCP-Server hinzufügen**
 4. Geben Sie die Server-Konfigurationsdetails ein
 5. Speichern Sie die Konfiguration
@@ -36,18 +40,14 @@ MCP-Server stellen Sammlungen von Tools bereit, die Ihre Agenten nutzen können.
 Sie können MCP-Server auch direkt über die Symbolleiste in einem Agent-Block für eine schnelle Einrichtung konfigurieren.
 </Callout>
 
-### Tools aktualisieren
+## Verwendung von MCP-Tools in Agenten
 
-Klicken Sie bei einem Server auf **Aktualisieren**, um die neuesten Tool-Schemas abzurufen und alle Agent-Blöcke, die diese Tools verwenden, automatisch mit den neuen Parameterdefinitionen zu aktualisieren.
-
-## MCP-Tools in Agents verwenden
-
-Sobald MCP-Server konfiguriert sind, werden ihre Tools in Ihren Agent-Blöcken verfügbar:
+Sobald MCP-Server konfiguriert sind, werden ihre Tools innerhalb Ihrer Agent-Blöcke verfügbar:
 
 <div className="flex justify-center">
   <Image
     src="/static/blocks/mcp-2.png"
-    alt="Using MCP Tool in Agent Block"
+    alt="Verwendung eines MCP-Tools im Agent-Block"
     width={700}
     height={450}
     className="my-6"
@@ -55,25 +55,25 @@ Sobald MCP-Server konfiguriert sind, werden ihre Tools in Ihren Agent-Blöcken v
 </div>
 
 1. Öffnen Sie einen **Agent**-Block
-2. Im Bereich **Tools** sehen Sie die verfügbaren MCP-Tools
+2. Im Abschnitt **Tools** sehen Sie die verfügbaren MCP-Tools
 3. Wählen Sie die Tools aus, die der Agent verwenden soll
 4. Der Agent kann nun während der Ausführung auf diese Tools zugreifen
 
 ## Eigenständiger MCP-Tool-Block
 
-Für eine präzisere Steuerung können Sie den dedizierten MCP-Tool-Block verwenden, um bestimmte MCP-Tools auszuführen:
+Für eine genauere Kontrolle können Sie den dedizierten MCP-Tool-Block verwenden, um bestimmte MCP-Tools auszuführen:
 
 <div className="flex justify-center">
   <Image
     src="/static/blocks/mcp-3.png"
-    alt="Standalone MCP Tool Block"
+    alt="Eigenständiger MCP-Tool-Block"
     width={700}
     height={450}
     className="my-6"
   />
 </div>
 
-Der MCP-Tool-Block ermöglicht Ihnen:
+Der MCP-Tool-Block ermöglicht es Ihnen:
 - Jedes konfigurierte MCP-Tool direkt auszuführen
 - Spezifische Parameter an das Tool zu übergeben
 - Die Ausgabe des Tools in nachfolgenden Workflow-Schritten zu verwenden
@@ -81,9 +81,9 @@ Der MCP-Tool-Block ermöglicht Ihnen:
 
 ### Wann MCP-Tool vs. Agent verwenden
 
-**Verwenden Sie Agent mit MCP-Tools, wenn:**
-- Sie möchten, dass die KI entscheidet, welche Tools verwendet werden
-- Sie komplexes Reasoning darüber benötigen, wann und wie Tools verwendet werden
+**Verwenden Sie einen Agenten mit MCP-Tools, wenn:**
+- Sie möchten, dass die KI entscheidet, welche Tools zu verwenden sind
+- Sie komplexe Überlegungen benötigen, wann und wie Tools eingesetzt werden sollen
 - Sie eine natürlichsprachliche Interaktion mit den Tools wünschen
 
 **Verwenden Sie den MCP-Tool-Block, wenn:**
@@ -93,7 +93,7 @@ Der MCP-Tool-Block ermöglicht Ihnen:
 
 ## Berechtigungsanforderungen
 
-Die MCP-Funktionalität erfordert spezifische Workspace-Berechtigungen:
+MCP-Funktionalität erfordert spezifische Workspace-Berechtigungen:
 
 | Aktion | Erforderliche Berechtigung |
 |--------|-------------------|
@@ -105,7 +105,7 @@ Die MCP-Funktionalität erfordert spezifische Workspace-Berechtigungen:
 ## Häufige Anwendungsfälle
 
 ### Datenbankintegration
-Verbinden Sie sich mit Datenbanken, um Daten in Ihren Workflows abzufragen, einzufügen oder zu aktualisieren.
+Verbinden Sie sich mit Datenbanken, um Daten innerhalb Ihrer Workflows abzufragen, einzufügen oder zu aktualisieren.
 
 ### API-Integrationen
 Greifen Sie auf externe APIs und Webdienste zu, die keine integrierten Sim-Integrationen haben.
@@ -113,8 +113,8 @@ Greifen Sie auf externe APIs und Webdienste zu, die keine integrierten Sim-Integ
 ### Dateisystemzugriff
 Lesen, schreiben und bearbeiten Sie Dateien auf lokalen oder entfernten Dateisystemen.
 
-### Individuelle Geschäftslogik
-Führen Sie benutzerdefinierte Skripte oder Tools aus, die spezifisch für die Anforderungen Ihrer Organisation sind.
+### Benutzerdefinierte Geschäftslogik
+Führen Sie benutzerdefinierte Skripte oder Tools aus, die auf die Bedürfnisse Ihrer Organisation zugeschnitten sind.
 
 ### Echtzeit-Datenzugriff
 Rufen Sie Live-Daten von externen Systemen während der Workflow-Ausführung ab.
@@ -128,12 +128,12 @@ Rufen Sie Live-Daten von externen Systemen während der Workflow-Ausführung ab.
 
 ## Fehlerbehebung
 
-### MCP-Server wird nicht angezeigt
+### MCP-Server erscheint nicht
 - Überprüfen Sie, ob die Serverkonfiguration korrekt ist
-- Prüfen Sie, ob Sie über die erforderlichen Berechtigungen verfügen
-- Stellen Sie sicher, dass der MCP-Server läuft und erreichbar ist
+- Prüfen Sie, ob Sie die erforderlichen Berechtigungen haben
+- Stellen Sie sicher, dass der MCP-Server läuft und zugänglich ist
 
-### Tool-Ausführungsfehler
+### Fehler bei der Tool-Ausführung
 - Überprüfen Sie, ob die Tool-Parameter korrekt formatiert sind
 - Prüfen Sie die MCP-Server-Logs auf Fehlermeldungen
 - Stellen Sie sicher, dass die erforderliche Authentifizierung konfiguriert ist
@@ -141,4 +141,4 @@ Rufen Sie Live-Daten von externen Systemen während der Workflow-Ausführung ab.
 ### Berechtigungsfehler
 - Bestätigen Sie Ihre Workspace-Berechtigungsstufe
 - Prüfen Sie, ob der MCP-Server zusätzliche Authentifizierung erfordert
-- Überprüfen Sie, ob der Server ordnungsgemäß für Ihren Workspace konfiguriert ist
+- Stellen Sie sicher, dass der Server für Ihren Workspace richtig konfiguriert ist

apps/docs/content/docs/de/tools/circleback.mdx

@@ -1,59 +0,0 @@
----
-title: Circleback
-description: KI-gestützte Meeting-Notizen und Aufgaben
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="circleback"
-  color="linear-gradient(180deg, #E0F7FA 0%, #FFFFFF 100%)"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Circleback](https://circleback.ai/) ist eine KI-gestützte Plattform, die Meeting-Notizen, Aufgaben, Transkripte und Aufzeichnungen für Ihr Team automatisiert. Wenn ein Meeting abgeschlossen ist, verarbeitet Circleback die Konversation und liefert detaillierte Notizen und Aufgaben sowie ein Transkript und eine Aufzeichnung (sofern verfügbar). Dies hilft Teams dabei, Erkenntnisse effizient zu erfassen, Aufgaben zu verteilen und sicherzustellen, dass nichts übersehen wird – alles nahtlos in Ihre Workflows integriert.
-
-Mit der Sim Circleback-Integration können Sie:
-
-- **Detaillierte Meeting-Notizen und Aufgaben erhalten**: Sammeln Sie automatisch gut formatierte Meeting-Zusammenfassungen und verfolgen Sie umsetzbare Aufgaben, die während Ihrer Anrufe besprochen wurden.
-- **Auf vollständige Meeting-Aufzeichnungen und Transkripte zugreifen**: Erhalten Sie die vollständige Konversation und die zugehörige Aufzeichnung, um wichtige Momente einfach zu überprüfen oder mit Kollegen zu teilen.
-- **Teilnehmerinformationen und Meeting-Kontext erfassen**: Teilnehmerlisten, Meeting-Metadaten und Tags helfen dabei, Ihre Daten organisiert und umsetzbar zu halten.
-- **Erkenntnisse direkt in Ihre Workflows liefern**: Lösen Sie Automatisierungen aus oder senden Sie Circleback-Daten an andere Systeme, sobald ein Meeting beendet ist, mithilfe der leistungsstarken Webhook-Trigger von Sim.
-
-**So funktioniert es in Sim:**  
-Circleback verwendet Webhook-Trigger: Sobald ein Meeting verarbeitet wurde, werden die Daten automatisch an Ihren Agenten oder Ihre Automatisierung übertragen. Sie können weitere Automatisierungen basierend auf folgenden Ereignissen erstellen:
-
-- Meeting abgeschlossen (alle verarbeiteten Daten verfügbar)
-- Neue Notizen (Notizen sind verfügbar, noch bevor das Meeting vollständig verarbeitet ist)
-- Raw-Webhook-Integration für erweiterte Anwendungsfälle
-
-**Die folgenden Informationen sind in der Circleback-Meeting-Webhook-Payload verfügbar:**
-
-| Feld          | Typ    | Beschreibung                                        |
-|----------------|---------|----------------------------------------------------|
-| `id`           | number  | Circleback Meeting-ID                              |
-| `name`         | string  | Meeting-Titel                                      |
-| `url`          | string  | Virtueller Meeting-Link (Zoom, Meet, Teams usw.)      |
-| `createdAt`    | string  | Zeitstempel der Meeting-Erstellung                         |
-| `duration`     | number  | Dauer in Sekunden                                |
-| `recordingUrl` | string  | Aufzeichnungs-URL (24 Stunden gültig)                     |
-| `tags`         | json    | Array von Tags                                      |
-| `icalUid`      | string  | Kalender-Event-ID                                  |
-| `attendees`    | json    | Array von Teilnehmer-Objekten                          |
-| `notes`        | string  | Meeting-Notizen in Markdown                          |
-| `actionItems`  | json    | Array von Aufgaben                              |
-| `transcript`   | json    | Array von Transkript-Segmenten                       |
-| `insights`     | json    | Vom Nutzer erstellte Insights                              |
-| `meeting`      | json    | Vollständige Meeting-Daten                               |
-
-Egal, ob Sie sofortige Zusammenfassungen verteilen, Aufgaben protokollieren oder benutzerdefinierte Workflows erstellen möchten, die durch neue Meeting-Daten ausgelöst werden – Circleback und Sim machen es nahtlos, alles rund um Ihre Meetings automatisch zu verwalten.
-{/* MANUAL-CONTENT-END */}
-
-## Nutzungsanleitung
-
-Erhalten Sie Meeting-Notizen, Aufgaben, Transkripte und Aufzeichnungen, wenn Meetings verarbeitet werden. Circleback nutzt Webhooks, um Daten an Ihre Workflows zu übermitteln.
-
-## Hinweise
-
-- Kategorie: `triggers`
-- Typ: `circleback`

apps/docs/content/docs/de/tools/firecrawl.mdx

@@ -146,32 +146,6 @@ Extrahieren Sie strukturierte Daten aus vollständigen Webseiten mithilfe von na
 | `success` | boolean | Ob der Extraktionsvorgang erfolgreich war |
 | `data` | object | Extrahierte strukturierte Daten gemäß dem Schema oder der Eingabeaufforderung |
 
-### `firecrawl_agent`
-
-Autonomer Web-Datenextraktions-Agent. Sucht und sammelt Informationen basierend auf natürlichsprachlichen Anweisungen, ohne dass spezifische URLs erforderlich sind.
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `prompt` | string | Ja | Natürlichsprachliche Beschreibung der zu extrahierenden Daten \(max. 10.000 Zeichen\) |
-| `urls` | json | Nein | Optionales Array von URLs, auf die sich der Agent konzentrieren soll |
-| `schema` | json | Nein | JSON-Schema, das die Struktur der zu extrahierenden Daten definiert |
-| `maxCredits` | number | Nein | Maximale Credits, die für diese Agent-Aufgabe verwendet werden sollen |
-| `strictConstrainToURLs` | boolean | Nein | Wenn true, besucht der Agent nur URLs, die im urls-Array angegeben sind |
-| `apiKey` | string | Ja | Firecrawl API-Schlüssel |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `success` | boolean | Ob die Agent-Operation erfolgreich war |
-| `status` | string | Aktueller Status des Agent-Jobs \(processing, completed, failed\) |
-| `data` | object | Vom Agent extrahierte Daten |
-| `creditsUsed` | number | Anzahl der von dieser Agent-Aufgabe verbrauchten Credits |
-| `expiresAt` | string | Zeitstempel, wann die Ergebnisse ablaufen \(24 Stunden\) |
-| `sources` | object | Array der vom Agent verwendeten Quell-URLs |
-
 ## Hinweise
 
 - Kategorie: `tools`

apps/docs/content/docs/de/tools/fireflies.mdx

@@ -1,233 +0,0 @@
----
-title: Fireflies
-description: Interagieren Sie mit Fireflies.ai-Besprechungstranskripten und -aufzeichnungen
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="fireflies"
-  color="#100730"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Fireflies.ai](https://fireflies.ai/) ist eine Plattform für Besprechungstranskription und -intelligenz, die sich in Sim integriert und es Ihren Agenten ermöglicht, direkt mit Besprechungsaufzeichnungen, Transkripten und Erkenntnissen über No-Code-Automatisierungen zu arbeiten.
-
-Die Fireflies-Integration in Sim bietet Tools für:
-
-- **Besprechungstranskripte auflisten:** Rufen Sie mehrere Besprechungen und deren Zusammenfassungsinformationen für Ihr Team oder Konto ab.
-- **Vollständige Transkriptdetails abrufen:** Greifen Sie auf detaillierte Transkripte zu, einschließlich Zusammenfassungen, Aktionspunkten, Themen und Teilnehmeranalysen für jede Besprechung.
-- **Audio oder Video hochladen:** Laden Sie Audio-/Videodateien hoch oder geben Sie URLs zur Transkription an – optional können Sie Sprache, Titel, Teilnehmer festlegen und automatisierte Besprechungsnotizen erhalten.
-- **Transkripte durchsuchen:** Finden Sie Besprechungen nach Stichwort, Teilnehmer, Moderator oder Zeitraum, um relevante Diskussionen schnell zu lokalisieren.
-- **Transkripte löschen:** Entfernen Sie bestimmte Besprechungstranskripte aus Ihrem Fireflies-Workspace.
-- **Soundbites (Bites) erstellen:** Extrahieren und markieren Sie wichtige Momente aus Transkripten als Audio- oder Videoclips.
-- **Workflows bei Transkriptionsabschluss auslösen:** Aktivieren Sie Sim-Workflows automatisch, wenn eine Fireflies-Besprechungstranskription abgeschlossen ist, mithilfe des bereitgestellten Webhook-Triggers – dies ermöglicht Echtzeit-Automatisierungen und Benachrichtigungen basierend auf neuen Besprechungsdaten.
-
-Durch die Kombination dieser Funktionen können Sie Aktionen nach Besprechungen optimieren, strukturierte Erkenntnisse extrahieren, Benachrichtigungen automatisieren, Aufzeichnungen verwalten und benutzerdefinierte Workflows rund um die Anrufe Ihrer Organisation orchestrieren – alles sicher unter Verwendung Ihres API-Schlüssels und Ihrer Fireflies-Anmeldedaten.
-{/* MANUAL-CONTENT-END */}
-
-## Nutzungsanweisungen
-
-Integrieren Sie Fireflies.ai in den Workflow. Verwalten Sie Besprechungstranskripte, fügen Sie Bots zu Live-Besprechungen hinzu, erstellen Sie Soundbites und mehr. Kann auch Workflows auslösen, wenn Transkriptionen abgeschlossen sind.
-
-## Tools
-
-### `fireflies_list_transcripts`
-
-Meeting-Transkripte von Fireflies.ai mit optionaler Filterung auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies API-Schlüssel |
-| `keyword` | string | Nein | Suchbegriff im Meeting-Titel oder Transkript |
-| `fromDate` | string | Nein | Transkripte ab diesem Datum filtern \(ISO 8601-Format\) |
-| `toDate` | string | Nein | Transkripte bis zu diesem Datum filtern \(ISO 8601-Format\) |
-| `hostEmail` | string | Nein | Nach E-Mail-Adresse des Meeting-Hosts filtern |
-| `participants` | string | Nein | Nach E-Mail-Adressen der Teilnehmer filtern \(durch Komma getrennt\) |
-| `limit` | number | Nein | Maximale Anzahl der zurückzugebenden Transkripte \(max. 50\) |
-| `skip` | number | Nein | Anzahl der zu überspringenden Transkripte für Paginierung |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `transcripts` | array | Liste der Transkripte |
-| `count` | number | Anzahl der zurückgegebenen Transkripte |
-
-### `fireflies_get_transcript`
-
-Ein einzelnes Transkript mit vollständigen Details einschließlich Zusammenfassung, Aktionspunkten und Analysen abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies API-Schlüssel |
-| `transcriptId` | string | Ja | Die abzurufende Transkript-ID |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `transcript` | object | Das Transkript mit vollständigen Details |
-
-### `fireflies_get_user`
-
-Ruft Benutzerinformationen von Fireflies.ai ab. Gibt den aktuellen Benutzer zurück, wenn keine ID angegeben ist.
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies-API-Schlüssel |
-| `userId` | string | Nein | Abzurufende Benutzer-ID \(optional, Standardwert ist der Inhaber des API-Schlüssels\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `user` | object | Benutzerinformationen |
-
-### `fireflies_list_users`
-
-Listet alle Benutzer in Ihrem Fireflies.ai-Team auf
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies-API-Schlüssel |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `users` | array | Liste der Teammitglieder |
-
-### `fireflies_upload_audio`
-
-Lädt eine Audiodatei-URL zur Transkription zu Fireflies.ai hoch
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies-API-Schlüssel |
-| `audioFile` | file | Nein | Audio-/Videodatei zur Transkription hochladen |
-| `audioUrl` | string | Nein | Öffentliche HTTPS-URL der Audio-/Videodatei \(MP3, MP4, WAV, M4A, OGG\) |
-| `title` | string | Nein | Titel für das Meeting/Transkript |
-| `webhook` | string | Nein | Webhook-URL zur Benachrichtigung, wenn die Transkription abgeschlossen ist |
-| `language` | string | Nein | Sprachcode für die Transkription \(z. B. „es" für Spanisch, „de" für Deutsch\) |
-| `attendees` | string | Nein | Teilnehmer im JSON-Format: \[\{"displayName": "Name", "email": "email@example.com"\}\] |
-| `clientReferenceId` | string | Nein | Benutzerdefinierte Referenz-ID zur Nachverfolgung |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `success` | boolean | Ob der Upload erfolgreich war |
-| `title` | string | Titel des hochgeladenen Meetings |
-| `message` | string | Statusmeldung von Fireflies |
-
-### `fireflies_delete_transcript`
-
-Ein Transkript von Fireflies.ai löschen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies API-Schlüssel |
-| `transcriptId` | string | Ja | Die zu löschende Transkript-ID |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `success` | boolean | Ob das Transkript erfolgreich gelöscht wurde |
-
-### `fireflies_add_to_live_meeting`
-
-Fügen Sie den Fireflies.ai-Bot zu einem laufenden Meeting hinzu, um aufzuzeichnen und zu transkribieren
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies API-Schlüssel |
-| `meetingLink` | string | Ja | Gültige Meeting-URL \(Zoom, Google Meet, Microsoft Teams, etc.\) |
-| `title` | string | Nein | Titel für das Meeting \(max. 256 Zeichen\) |
-| `meetingPassword` | string | Nein | Passwort für das Meeting, falls erforderlich \(max. 32 Zeichen\) |
-| `duration` | number | Nein | Meetingdauer in Minuten \(15–120, Standard: 60\) |
-| `language` | string | Nein | Sprachcode für die Transkription \(z. B. "en", "es", "de"\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `success` | boolean | Ob der Bot erfolgreich zum Meeting hinzugefügt wurde |
-
-### `fireflies_create_bite`
-
-Erstellen Sie einen Soundbite/Highlight aus einem bestimmten Zeitbereich in einem Transkript
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies API-Schlüssel |
-| `transcriptId` | string | Ja | ID des Transkripts, aus dem der Bite erstellt werden soll |
-| `startTime` | number | Ja | Startzeit des Bites in Sekunden |
-| `endTime` | number | Ja | Endzeit des Bites in Sekunden |
-| `name` | string | Nein | Name für den Bite \(max. 256 Zeichen\) |
-| `mediaType` | string | Nein | Medientyp: "video" oder "audio" |
-| `summary` | string | Nein | Zusammenfassung für den Bite \(max. 500 Zeichen\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `bite` | object | Details des erstellten Bites |
-
-### `fireflies_list_bites`
-
-Soundbites/Highlights von Fireflies.ai auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies API-Schlüssel |
-| `transcriptId` | string | Nein | Bites für ein bestimmtes Transkript filtern |
-| `mine` | boolean | Nein | Nur Bites zurückgeben, die dem Besitzer des API-Schlüssels gehören \(Standard: true\) |
-| `limit` | number | Nein | Maximale Anzahl der zurückzugebenden Bites \(max. 50\) |
-| `skip` | number | Nein | Anzahl der zu überspringenden Bites für die Paginierung |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `bites` | array | Liste der Bites/Soundbites |
-
-### `fireflies_list_contacts`
-
-Alle Kontakte aus Ihren Fireflies.ai-Meetings auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Fireflies-API-Schlüssel |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `contacts` | array | Liste der Kontakte aus Meetings |
-
-## Hinweise
-
-- Kategorie: `tools`
-- Typ: `fireflies`

apps/docs/content/docs/de/tools/generic_webhook.mdx

@@ -0,0 +1,231 @@
+---
+title: Webhook
+description: Empfangen Sie Webhooks von jedem Dienst durch Konfiguration eines
+  benutzerdefinierten Webhooks.
+---
+
+import { BlockInfoCard } from "@/components/ui/block-info-card"
+import { Image } from '@/components/ui/image'
+
+<BlockInfoCard 
+  type="generic_webhook"
+  color="#10B981"
+/>
+
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/webhook.png"
+    alt="Webhook-Block-Konfiguration"
+    width={500}
+    height={400}
+    className="my-6"
+  />
+</div>
+
+## Übersicht
+
+Der generische Webhook-Block ermöglicht den Empfang von Webhooks von jedem externen Dienst. Dies ist ein flexibler Trigger, der jede JSON-Nutzlast verarbeiten kann und sich daher ideal für die Integration mit Diensten eignet, die keinen dedizierten Sim-Block haben.
+
+## Grundlegende Verwendung
+
+### Einfacher Durchleitungsmodus
+
+Ohne ein definiertes Eingabeformat leitet der Webhook den gesamten Anforderungstext unverändert weiter:
+
+```bash
+curl -X POST https://sim.ai/api/webhooks/trigger/{webhook-path} \
+  -H "Content-Type: application/json" \
+  -H "X-Sim-Secret: your-secret" \
+  -d '{
+    "message": "Test webhook trigger",
+    "data": {
+      "key": "value"
+    }
+  }'
+```
+
+Greifen Sie in nachgelagerten Blöcken auf die Daten zu mit:
+- `<webhook1.message>` → "Test webhook trigger"
+- `<webhook1.data.key>` → "value"
+
+### Strukturiertes Eingabeformat (optional)
+
+Definieren Sie ein Eingabeschema, um typisierte Felder zu erhalten und erweiterte Funktionen wie Datei-Uploads zu aktivieren:
+
+**Konfiguration des Eingabeformats:**
+
+```json
+[
+  { "name": "message", "type": "string" },
+  { "name": "priority", "type": "number" },
+  { "name": "documents", "type": "files" }
+]
+```
+
+**Webhook-Anfrage:**
+
+```bash
+curl -X POST https://sim.ai/api/webhooks/trigger/{webhook-path} \
+  -H "Content-Type: application/json" \
+  -H "X-Sim-Secret: your-secret" \
+  -d '{
+    "message": "Invoice submission",
+    "priority": 1,
+    "documents": [
+      {
+        "type": "file",
+        "data": "data:application/pdf;base64,JVBERi0xLjQK...",
+        "name": "invoice.pdf",
+        "mime": "application/pdf"
+      }
+    ]
+  }'
+```
+
+## Datei-Uploads
+
+### Unterstützte Dateiformate
+
+Der Webhook unterstützt zwei Dateieingabeformate:
+
+#### 1. Base64-kodierte Dateien
+Zum direkten Hochladen von Dateiinhalten:
+
+```json
+{
+  "documents": [
+    {
+      "type": "file",
+      "data": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgA...",
+      "name": "screenshot.png",
+      "mime": "image/png"
+    }
+  ]
+}
+```
+
+- **Maximale Größe**: 20MB pro Datei
+- **Format**: Standard-Daten-URL mit Base64-Kodierung
+- **Speicherung**: Dateien werden in sicheren Ausführungsspeicher hochgeladen
+
+#### 2. URL-Referenzen
+Zum Übergeben vorhandener Datei-URLs:
+
+```json
+{
+  "documents": [
+    {
+      "type": "url",
+      "data": "https://example.com/files/document.pdf",
+      "name": "document.pdf",
+      "mime": "application/pdf"
+    }
+  ]
+}
+```
+
+### Zugriff auf Dateien in nachgelagerten Blöcken
+
+Dateien werden in `UserFile`Objekte mit den folgenden Eigenschaften verarbeitet:
+
+```typescript
+{
+  id: string,          // Unique file identifier
+  name: string,        // Original filename
+  url: string,         // Presigned URL (valid for 5 minutes)
+  size: number,        // File size in bytes
+  type: string,        // MIME type
+  key: string,         // Storage key
+  uploadedAt: string,  // ISO timestamp
+  expiresAt: string    // ISO timestamp (5 minutes)
+}
+```
+
+**Zugriff in Blöcken:**
+- `<webhook1.documents[0].url>` → Download-URL
+- `<webhook1.documents[0].name>` → "invoice.pdf"
+- `<webhook1.documents[0].size>` → 524288
+- `<webhook1.documents[0].type>` → "application/pdf"
+
+### Vollständiges Datei-Upload-Beispiel
+
+```bash
+# Create a base64-encoded file
+echo "Hello World" | base64
+# SGVsbG8gV29ybGQK
+
+# Send webhook with file
+curl -X POST https://sim.ai/api/webhooks/trigger/{webhook-path} \
+  -H "Content-Type: application/json" \
+  -H "X-Sim-Secret: your-secret" \
+  -d '{
+    "subject": "Document for review",
+    "attachments": [
+      {
+        "type": "file",
+        "data": "data:text/plain;base64,SGVsbG8gV29ybGQK",
+        "name": "sample.txt",
+        "mime": "text/plain"
+      }
+    ]
+  }'
+```
+
+## Authentifizierung
+
+### Authentifizierung konfigurieren (Optional)
+
+In der Webhook-Konfiguration:
+1. Aktiviere "Authentifizierung erforderlich"
+2. Setze einen geheimen Token
+3. Wähle den Header-Typ:
+   - **Benutzerdefinierter Header**: `X-Sim-Secret: your-token`
+   - **Authorization Bearer**: `Authorization: Bearer your-token`
+
+### Verwendung der Authentifizierung
+
+```bash
+# With custom header
+curl -X POST https://sim.ai/api/webhooks/trigger/{webhook-path} \
+  -H "Content-Type: application/json" \
+  -H "X-Sim-Secret: your-secret-token" \
+  -d '{"message": "Authenticated request"}'
+
+# With bearer token
+curl -X POST https://sim.ai/api/webhooks/trigger/{webhook-path} \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your-secret-token" \
+  -d '{"message": "Authenticated request"}'
+```
+
+## Best Practices
+
+1. **Eingabeformat für Struktur verwenden**: Definiere ein Eingabeformat, wenn du das erwartete Schema kennst. Dies bietet:
+   - Typvalidierung
+   - Bessere Autovervollständigung im Editor
+   - Datei-Upload-Funktionen
+
+2. **Authentifizierung**: Aktiviere immer die Authentifizierung für Produktions-Webhooks, um unbefugten Zugriff zu verhindern.
+
+3. **Dateigrößenbeschränkungen**: Halte Dateien unter 20 MB. Verwende für größere Dateien URL-Referenzen.
+
+4. **Dateiablauf**: Heruntergeladene Dateien haben URLs mit einer Gültigkeit von 5 Minuten. Verarbeite sie umgehend oder speichere sie an anderer Stelle, wenn sie länger benötigt werden.
+
+5. **Fehlerbehandlung**: Die Webhook-Verarbeitung erfolgt asynchron. Überprüfe die Ausführungsprotokolle auf Fehler.
+
+6. **Testen**: Verwende die Schaltfläche "Webhook testen" im Editor, um deine Konfiguration vor der Bereitstellung zu validieren.
+
+## Anwendungsfälle
+
+- **Formularübermittlungen**: Empfange Daten von benutzerdefinierten Formularen mit Datei-Uploads
+- **Drittanbieter-Integrationen**: Verbinde mit Diensten, die Webhooks senden (Stripe, GitHub usw.)
+- **Dokumentenverarbeitung**: Akzeptiere Dokumente von externen Systemen zur Verarbeitung
+- **Ereignisbenachrichtigungen**: Empfange Ereignisdaten aus verschiedenen Quellen
+- **Benutzerdefinierte APIs**: Erstelle benutzerdefinierte API-Endpunkte für deine Anwendungen
+
+## Hinweise
+
+- Kategorie: `triggers`
+- Typ: `generic_webhook`
+- **Dateiunterstützung**: Verfügbar über Eingabeformat-Konfiguration
+- **Maximale Dateigröße**: 20 MB pro Datei

apps/docs/content/docs/de/tools/grain.mdx

@@ -1,218 +0,0 @@
----
-title: Grain
-description: Zugriff auf Meeting-Aufzeichnungen, Transkripte und KI-Zusammenfassungen
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="grain"
-  color="#F6FAF9"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Grain](https://grain.com/) ist eine moderne Plattform zum Erfassen, Speichern und Teilen von Meeting-Aufzeichnungen, Transkripten, Highlights und KI-gestützten Zusammenfassungen. Grain ermöglicht es Teams, Gespräche in umsetzbare Erkenntnisse zu verwandeln und alle über wichtige Momente aus Meetings auf dem Laufenden zu halten.
-
-Mit Grain können Sie:
-
-- **Auf durchsuchbare Aufzeichnungen und Transkripte zugreifen**: Finden und überprüfen Sie jedes Meeting nach Stichwort, Teilnehmer oder Thema.
-- **Highlights und Clips teilen**: Erfassen Sie wichtige Momente und teilen Sie kurze Video-/Audio-Highlights in Ihrem Team oder in Workflows.
-- **KI-generierte Zusammenfassungen erhalten**: Erstellen Sie automatisch Meeting-Zusammenfassungen, Aktionspunkte und wichtige Erkenntnisse mithilfe der fortschrittlichen KI von Grain.
-- **Meetings nach Team oder Typ organisieren**: Taggen und kategorisieren Sie Aufzeichnungen für einfachen Zugriff und Reporting.
-
-Die Sim-Grain-Integration ermöglicht es Ihren Agenten:
-
-- Meeting-Aufzeichnungen und Details nach flexiblen Filtern (Datum/Uhrzeit, Teilnehmer, Team usw.) aufzulisten, zu suchen und abzurufen.
-- Auf KI-Zusammenfassungen, Teilnehmer, Highlights und andere Metadaten für Meetings zuzugreifen, um Automatisierungen oder Analysen zu unterstützen.
-- Workflows auszulösen, sobald neue Meetings verarbeitet, Zusammenfassungen generiert oder Highlights über Grain-Webhooks erstellt werden.
-- Grain-Daten einfach in andere Tools zu überführen oder Teammitglieder zu benachrichtigen, sobald etwas Wichtiges in einem Meeting passiert.
-
-Ob Sie Follow-up-Aktionen automatisieren, wichtige Gespräche dokumentieren oder Erkenntnisse in Ihrer Organisation sichtbar machen möchten – Grain und Sim machen es einfach, Meeting-Intelligence mit Ihren Workflows zu verbinden.
-{/* MANUAL-CONTENT-END */}
-
-## Nutzungsanweisungen
-
-Integrieren Sie Grain in Ihren Workflow. Greifen Sie auf Meeting-Aufzeichnungen, Transkripte, Highlights und KI-generierte Zusammenfassungen zu. Kann auch Workflows basierend auf Grain-Webhook-Ereignissen auslösen.
-
-## Tools
-
-### `grain_list_recordings`
-
-Aufzeichnungen von Grain mit optionalen Filtern und Paginierung auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain API-Schlüssel \(Personal Access Token\) |
-| `cursor` | string | Nein | Paginierungs-Cursor für nächste Seite |
-| `beforeDatetime` | string | Nein | Nur Aufzeichnungen vor diesem ISO8601-Zeitstempel |
-| `afterDatetime` | string | Nein | Nur Aufzeichnungen nach diesem ISO8601-Zeitstempel |
-| `participantScope` | string | Nein | Filter: "internal" oder "external" |
-| `titleSearch` | string | Nein | Suchbegriff zum Filtern nach Aufzeichnungstitel |
-| `teamId` | string | Nein | Nach Team-UUID filtern |
-| `meetingTypeId` | string | Nein | Nach Meeting-Typ-UUID filtern |
-| `includeHighlights` | boolean | Nein | Highlights/Clips in Antwort einschließen |
-| `includeParticipants` | boolean | Nein | Teilnehmerliste in Antwort einschließen |
-| `includeAiSummary` | boolean | Nein | KI-generierte Zusammenfassung einschließen |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `recordings` | array | Array von Aufzeichnungsobjekten |
-
-### `grain_get_recording`
-
-Details einer einzelnen Aufzeichnung nach ID abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain API-Schlüssel \(Personal Access Token\) |
-| `recordingId` | string | Ja | Die Aufzeichnungs-UUID |
-| `includeHighlights` | boolean | Nein | Highlights/Clips einschließen |
-| `includeParticipants` | boolean | Nein | Teilnehmerliste einschließen |
-| `includeAiSummary` | boolean | Nein | KI-Zusammenfassung einschließen |
-| `includeCalendarEvent` | boolean | Nein | Kalenderereignisdaten einschließen |
-| `includeHubspot` | boolean | Nein | HubSpot-Verknüpfungen einschließen |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `id` | string | Aufnahme-UUID |
-| `title` | string | Aufnahmetitel |
-| `start_datetime` | string | ISO8601-Startzeitstempel |
-| `end_datetime` | string | ISO8601-Endzeitstempel |
-| `duration_ms` | number | Dauer in Millisekunden |
-| `media_type` | string | audio, transcript oder video |
-| `source` | string | Aufnahmequelle \(zoom, meet, teams, etc.\) |
-| `url` | string | URL zur Ansicht in Grain |
-| `thumbnail_url` | string | Vorschaubild-URL |
-| `tags` | array | Array von Tag-Strings |
-| `teams` | array | Teams, zu denen die Aufnahme gehört |
-| `meeting_type` | object | Meeting-Typ-Informationen \(id, name, scope\) |
-| `highlights` | array | Highlights \(falls enthalten\) |
-| `participants` | array | Teilnehmer \(falls enthalten\) |
-| `ai_summary` | object | KI-Zusammenfassungstext \(falls enthalten\) |
-| `calendar_event` | object | Kalenderereignisdaten \(falls enthalten\) |
-| `hubspot` | object | HubSpot-Verknüpfungen \(falls enthalten\) |
-
-### `grain_get_transcript`
-
-Vollständiges Transkript einer Aufnahme abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain-API-Schlüssel \(Personal Access Token\) |
-| `recordingId` | string | Ja | Die Aufnahme-UUID |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `transcript` | array | Array von Transkriptabschnitten |
-
-### `grain_list_teams`
-
-Alle Teams im Workspace auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain API-Schlüssel \(Personal Access Token\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `teams` | array | Array von Team-Objekten |
-
-### `grain_list_meeting_types`
-
-Alle Meeting-Typen im Workspace auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain API-Schlüssel \(Personal Access Token\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `meeting_types` | array | Array von Meeting-Typ-Objekten |
-
-### `grain_create_hook`
-
-Einen Webhook erstellen, um Aufzeichnungs-Events zu empfangen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain API-Schlüssel \(Personal Access Token\) |
-| `hookUrl` | string | Ja | Webhook-Endpunkt-URL \(muss mit 2xx antworten\) |
-| `filterBeforeDatetime` | string | Nein | Filter: Aufzeichnungen vor diesem Datum |
-| `filterAfterDatetime` | string | Nein | Filter: Aufzeichnungen nach diesem Datum |
-| `filterParticipantScope` | string | Nein | Filter: "internal" oder "external" |
-| `filterTeamId` | string | Nein | Filter: spezifische Team-UUID |
-| `filterMeetingTypeId` | string | Nein | Filter: spezifischer Meeting-Typ |
-| `includeHighlights` | boolean | Nein | Highlights in Webhook-Payload einschließen |
-| `includeParticipants` | boolean | Nein | Teilnehmer in Webhook-Payload einschließen |
-| `includeAiSummary` | boolean | Nein | KI-Zusammenfassung in Webhook-Payload einschließen |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `id` | string | Hook-UUID |
-| `enabled` | boolean | Ob der Hook aktiv ist |
-| `hook_url` | string | Die Webhook-URL |
-| `filter` | object | Angewendete Filter |
-| `include` | object | Enthaltene Felder |
-| `inserted_at` | string | ISO8601-Erstellungszeitstempel |
-
-### `grain_list_hooks`
-
-Alle Webhooks für das Konto auflisten
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain-API-Schlüssel \(Personal Access Token\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `hooks` | array | Array von Hook-Objekten |
-
-### `grain_delete_hook`
-
-Einen Webhook anhand der ID löschen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Ja | Grain-API-Schlüssel \(Personal Access Token\) |
-| `hookId` | string | Ja | Die zu löschende Hook-UUID |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `success` | boolean | True, wenn der Webhook erfolgreich gelöscht wurde |
-
-## Hinweise
-
-- Kategorie: `tools`
-- Typ: `grain`

apps/docs/content/docs/de/tools/greptile.mdx

@@ -1,136 +0,0 @@
----
-title: Greptile
-description: KI-gestützte Codebase-Suche und Fragen & Antworten
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="greptile"
-  color="#e5e5e5"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Greptile](https://greptile.com/) ist ein KI-gestütztes Entwicklertool zum Durchsuchen und Abfragen von Quellcode über ein oder mehrere Repositories hinweg. Greptile ermöglicht es Entwicklern, komplexe Fragen zur Codebase schnell in natürlicher Sprache zu beantworten, relevante Dateien oder Symbole zu finden und Einblicke in unbekannten oder Legacy-Code zu gewinnen.
-
-Mit Greptile können Sie:
-
-- **Komplexe Fragen zu Ihrer Codebase in natürlicher Sprache stellen**: Erhalten Sie KI-generierte Antworten zu Architektur, Verwendungsmustern oder spezifischen Implementierungen.
-- **Relevanten Code, Dateien oder Funktionen sofort finden**: Suchen Sie mit Schlüsselwörtern oder natürlichsprachlichen Abfragen und springen Sie direkt zu passenden Zeilen, Dateien oder Codeblöcken.
-- **Abhängigkeiten und Beziehungen verstehen**: Entdecken Sie, wo Funktionen aufgerufen werden, wie Module miteinander verbunden sind oder wo APIs in großen Codebasen verwendet werden.
-- **Onboarding und Code-Exploration beschleunigen**: Arbeiten Sie sich schnell in neue Projekte ein oder debuggen Sie knifflige Probleme, ohne tiefgreifenden Vorkontext zu benötigen.
-
-Die Sim Greptile-Integration ermöglicht es Ihren KI-Agenten:
-
-- Private und öffentliche Repositories mithilfe der fortschrittlichen Sprachmodelle von Greptile abzufragen und zu durchsuchen.
-- Kontextuell relevante Code-Snippets, Dateiverweise und Erklärungen abzurufen, um Code-Reviews, Dokumentation und Entwicklungsworkflows zu unterstützen.
-- Automatisierungen in Sim-Workflows basierend auf Such-/Abfrageergebnissen auszulösen oder Code-Intelligenz direkt in Ihre Prozesse einzubetten.
-
-Egal, ob Sie die Produktivität von Entwicklern beschleunigen, Dokumentation automatisieren oder das Verständnis Ihres Teams für eine komplexe Codebase verbessern möchten – Greptile und Sim bieten nahtlosen Zugriff auf Code-Intelligenz und Suche, genau dort, wo Sie sie benötigen.
-{/* MANUAL-CONTENT-END */}
-
-## Nutzungsanleitung
-
-Fragen Sie Codebasen mit natürlicher Sprache über Greptile ab und durchsuchen Sie sie. Erhalten Sie KI-generierte Antworten zu Ihrem Code, finden Sie relevante Dateien und verstehen Sie komplexe Codebasen.
-
-## Tools
-
-### `greptile_query`
-
-Durchsuchen Sie Repositories in natürlicher Sprache und erhalten Sie Antworten mit relevanten Code-Referenzen. Greptile nutzt KI, um Ihre Codebasis zu verstehen und Fragen zu beantworten.
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `query` | string | Ja | Frage in natürlicher Sprache zur Codebasis |
-| `repositories` | string | Ja | Kommagetrennte Liste von Repositories. Format: "github:branch:owner/repo" oder nur "owner/repo" \(Standard ist github:main\) |
-| `sessionId` | string | Nein | Sitzungs-ID für Gesprächskontinuität |
-| `genius` | boolean | Nein | Genius-Modus für gründlichere Analyse aktivieren \(langsamer, aber genauer\) |
-| `apiKey` | string | Ja | Greptile-API-Schlüssel |
-| `githubToken` | string | Ja | GitHub Personal Access Token mit Lesezugriff auf Repositories |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `message` | string | KI-generierte Antwort auf die Anfrage |
-| `sources` | array | Relevante Code-Referenzen, die die Antwort unterstützen |
-
-### `greptile_search`
-
-Durchsuchen Sie Repositories in natürlicher Sprache und erhalten Sie relevante Code-Referenzen ohne Generierung einer Antwort. Nützlich zum Auffinden spezifischer Code-Stellen.
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `query` | string | Ja | Suchanfrage in natürlicher Sprache zum Auffinden relevanten Codes |
-| `repositories` | string | Ja | Kommagetrennte Liste von Repositories. Format: "github:branch:owner/repo" oder nur "owner/repo" \(Standard ist github:main\) |
-| `sessionId` | string | Nein | Sitzungs-ID für Gesprächskontinuität |
-| `genius` | boolean | Nein | Genius-Modus für gründlichere Suche aktivieren \(langsamer, aber genauer\) |
-| `apiKey` | string | Ja | Greptile-API-Schlüssel |
-| `githubToken` | string | Ja | GitHub Personal Access Token mit Lesezugriff auf Repositories |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `sources` | array | Relevante Code-Referenzen, die zur Suchanfrage passen |
-
-### `greptile_index_repo`
-
-Übermitteln Sie ein Repository zur Indexierung durch Greptile. Die Indexierung muss abgeschlossen sein, bevor das Repository abgefragt werden kann. Kleine Repositories benötigen 3-5 Minuten, größere können über eine Stunde dauern.
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `remote` | string | Ja | Git-Remote-Typ: github oder gitlab |
-| `repository` | string | Ja | Repository im Format owner/repo \(z. B. "facebook/react"\) |
-| `branch` | string | Ja | Zu indexierender Branch \(z. B. "main" oder "master"\) |
-| `reload` | boolean | Nein | Neuindexierung erzwingen, auch wenn bereits indexiert |
-| `notify` | boolean | Nein | E-Mail-Benachrichtigung senden, wenn Indexierung abgeschlossen ist |
-| `apiKey` | string | Ja | Greptile-API-Schlüssel |
-| `githubToken` | string | Ja | GitHub Personal Access Token mit Lesezugriff auf Repository |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `repositoryId` | string | Eindeutige Kennung für das indexierte Repository \(Format: remote:branch:owner/repo\) |
-| `statusEndpoint` | string | URL-Endpunkt zur Überprüfung des Indexierungsstatus |
-| `message` | string | Statusmeldung über den Indexierungsvorgang |
-
-### `greptile_status`
-
-Überprüfen Sie den Indexierungsstatus eines Repositories. Verwenden Sie dies, um zu verifizieren, ob ein Repository abfragebereit ist, oder um den Indexierungsfortschritt zu überwachen.
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `remote` | string | Ja | Git-Remote-Typ: github oder gitlab |
-| `repository` | string | Ja | Repository im Format owner/repo \(z. B. "facebook/react"\) |
-| `branch` | string | Ja | Branch-Name \(z. B. "main" oder "master"\) |
-| `apiKey` | string | Ja | Greptile-API-Schlüssel |
-| `githubToken` | string | Ja | GitHub Personal Access Token mit Lesezugriff auf das Repository |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `repository` | string | Repository-Name \(owner/repo\) |
-| `remote` | string | Git-Remote \(github/gitlab\) |
-| `branch` | string | Branch-Name |
-| `private` | boolean | Ob das Repository privat ist |
-| `status` | string | Indexierungsstatus: submitted, cloning, processing, completed oder failed |
-| `filesProcessed` | number | Anzahl der bisher verarbeiteten Dateien |
-| `numFiles` | number | Gesamtanzahl der Dateien im Repository |
-| `sampleQuestions` | array | Beispielfragen für das indexierte Repository |
-| `sha` | string | Git-Commit-SHA der indexierten Version |
-
-## Hinweise
-
-- Kategorie: `tools`
-- Typ: `greptile`

apps/docs/content/docs/de/tools/imap.mdx

@@ -1,36 +0,0 @@
----
-title: IMAP-E-Mail
-description: Workflows auslösen, wenn neue E-Mails über IMAP eintreffen
-  (funktioniert mit jedem E-Mail-Anbieter)
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="imap"
-  color="#6366F1"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-Der IMAP-E-Mail-Trigger ermöglicht es Ihren Sim-Workflows, automatisch zu starten, sobald eine neue E-Mail in einem Postfach empfangen wird, das das IMAP-Protokoll unterstützt. Dies funktioniert mit Gmail, Outlook, Yahoo und den meisten anderen E-Mail-Anbietern.
-
-Mit dem IMAP-Trigger können Sie:
-
-- **E-Mail-Verarbeitung automatisieren**: Starten Sie Workflows in Echtzeit, wenn neue Nachrichten in Ihrem Posteingang eintreffen.
-- **Nach Absender, Betreff oder Ordner filtern**: Konfigurieren Sie Ihren Trigger so, dass er nur auf E-Mails reagiert, die bestimmte Bedingungen erfüllen.
-- **Anhänge extrahieren und verarbeiten**: Laden Sie Dateianhänge automatisch herunter und verwenden Sie sie in Ihren automatisierten Abläufen.
-- **E-Mail-Inhalte parsen und verwenden**: Greifen Sie auf Betreff, Absender, Empfänger, vollständigen Text und andere Metadaten in nachfolgenden Workflow-Schritten zu.
-- **Mit jedem E-Mail-Anbieter integrieren**: Funktioniert mit jedem Dienst, der standardmäßigen IMAP-Zugriff bietet, ohne Vendor-Lock-in.
-- **Bei ungelesenen, markierten oder benutzerdefinierten Kriterien auslösen**: Richten Sie erweiterte Filter für die Arten von E-Mails ein, die Ihre Workflows starten.
-
-Mit Sim gibt Ihnen die IMAP-Integration die Möglichkeit, E-Mails in eine handlungsfähige Automatisierungsquelle zu verwandeln. Reagieren Sie auf Kundenanfragen, verarbeiten Sie Benachrichtigungen, starten Sie Daten-Pipelines und mehr – direkt aus Ihrem E-Mail-Posteingang, ohne manuelles Eingreifen.
-{/* MANUAL-CONTENT-END */}
-
-## Nutzungsanleitung
-
-Verbinden Sie sich über das IMAP-Protokoll mit jedem E-Mail-Server, um Workflows auszulösen, wenn neue E-Mails empfangen werden. Unterstützt Gmail, Outlook, Yahoo und jeden anderen IMAP-kompatiblen E-Mail-Anbieter.
-
-## Hinweise
-
-- Kategorie: `triggers`
-- Typ: `imap`

apps/docs/content/docs/de/tools/intercom.mdx

@@ -38,7 +38,6 @@ Erstellen Sie einen neuen Kontakt in Intercom mit E-Mail, external_id oder Rolle
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `role` | string | Nein | Die Rolle des Kontakts. Akzeptiert 'user' oder 'lead'. Standardmäßig 'lead', wenn nicht angegeben. |
 | `email` | string | Nein | Die E-Mail-Adresse des Kontakts |
 | `external_id` | string | Nein | Eine eindeutige Kennung für den Kontakt, die vom Client bereitgestellt wird |
 | `phone` | string | Nein | Die Telefonnummer des Kontakts |
@@ -46,16 +45,16 @@ Erstellen Sie einen neuen Kontakt in Intercom mit E-Mail, external_id oder Rolle
 | `avatar` | string | Nein | Eine Avatar-Bild-URL für den Kontakt |
 | `signed_up_at` | number | Nein | Der Zeitpunkt der Registrierung des Benutzers als Unix-Zeitstempel |
 | `last_seen_at` | number | Nein | Der Zeitpunkt, zu dem der Benutzer zuletzt gesehen wurde, als Unix-Zeitstempel |
-| `owner_id` | string | Nein | Die ID eines Administrators, dem die Kontoverantwortung für den Kontakt zugewiesen wurde |
-| `unsubscribed_from_emails` | boolean | Nein | Ob der Kontakt von E-Mails abgemeldet ist |
-| `custom_attributes` | string | Nein | Benutzerdefinierte Attribute als JSON-Objekt \(z. B. \{"attribute_name": "value"\}\) |
-| `company_id` | string | Nein | Unternehmens-ID, mit der der Kontakt bei der Erstellung verknüpft werden soll |
+| `owner_id` | string | Nein | Die ID eines Administrators, dem die Kontoinhaberschaft des Kontakts zugewiesen wurde |
+| `unsubscribed_from_emails` | boolean | Nein | Ob der Kontakt E-Mails abbestellt hat |
+| `custom_attributes` | string | Nein | Benutzerdefinierte Attribute als JSON-Objekt \(z.B. \{"attribute_name": "value"\}\) |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `contact` | object | Erstelltes Kontaktobjekt |
+| `success` | boolean | Erfolgsstatus der Operation |
+| `output` | object | Erstellte Kontaktdaten |
 
 ### `intercom_get_contact`
 
@@ -71,7 +70,8 @@ Einen einzelnen Kontakt anhand der ID von Intercom abrufen
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `contact` | object | Kontaktobjekt |
+| `success` | boolean | Erfolgsstatus der Operation |
+| `output` | object | Kontaktdaten |
 
 ### `intercom_update_contact`
 
@@ -81,25 +81,23 @@ Einen bestehenden Kontakt in Intercom aktualisieren
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `contactId` | string | Ja | Kontakt-ID, die aktualisiert werden soll |
-| `role` | string | Nein | Die Rolle des Kontakts. Akzeptiert 'user' oder 'lead'. |
-| `external_id` | string | Nein | Eine eindeutige Kennung für den Kontakt, die vom Client bereitgestellt wird |
+| `contactId` | string | Ja | Zu aktualisierende Kontakt-ID |
 | `email` | string | Nein | Die E-Mail-Adresse des Kontakts |
 | `phone` | string | Nein | Die Telefonnummer des Kontakts |
 | `name` | string | Nein | Der Name des Kontakts |
 | `avatar` | string | Nein | Eine Avatar-Bild-URL für den Kontakt |
-| `signed_up_at` | number | Nein | Der Zeitpunkt der Registrierung des Benutzers als Unix-Zeitstempel |
-| `last_seen_at` | number | Nein | Der Zeitpunkt, zu dem der Benutzer zuletzt gesehen wurde, als Unix-Zeitstempel |
-| `owner_id` | string | Nein | Die ID eines Administrators, dem die Kontoverantwortung für den Kontakt zugewiesen wurde |
-| `unsubscribed_from_emails` | boolean | Nein | Ob der Kontakt von E-Mails abgemeldet ist |
-| `custom_attributes` | string | Nein | Benutzerdefinierte Attribute als JSON-Objekt \(z. B. \{"attribute_name": "value"\}\) |
-| `company_id` | string | Nein | Unternehmens-ID, mit der der Kontakt verknüpft werden soll |
+| `signed_up_at` | number | Nein | Der Zeitpunkt der Registrierung des Benutzers als Unix-Timestamp |
+| `last_seen_at` | number | Nein | Der Zeitpunkt, zu dem der Benutzer zuletzt gesehen wurde, als Unix-Timestamp |
+| `owner_id` | string | Nein | Die ID eines Administrators, dem die Kontoeigentümerschaft des Kontakts zugewiesen wurde |
+| `unsubscribed_from_emails` | boolean | Nein | Ob der Kontakt E-Mails abbestellt hat |
+| `custom_attributes` | string | Nein | Benutzerdefinierte Attribute als JSON-Objekt \(z.B. \{"attribut_name": "wert"\}\) |
 
 #### Output
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `contact` | object | Aktualisiertes Kontaktobjekt |
+| `success` | boolean | Erfolgsstatus der Operation |
+| `output` | object | Aktualisierte Kontaktdaten |
 
 ### `intercom_list_contacts`
 
@@ -116,7 +114,8 @@ Alle Kontakte von Intercom mit Paginierungsunterstützung auflisten
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `contacts` | array | Array von Kontaktobjekten |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Liste der Kontakte |
 
 ### `intercom_search_contacts`
 
@@ -126,17 +125,16 @@ Suche nach Kontakten in Intercom mit einer Abfrage
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `query` | string | Ja | Suchabfrage (z. B. \{"field":"email","operator":"=","value":"user@example.com"\}) |
+| `query` | string | Ja | Suchabfrage (z.B., \{"field":"email","operator":"=","value":"user@example.com"\}) |
 | `per_page` | number | Nein | Anzahl der Ergebnisse pro Seite (max: 150) |
 | `starting_after` | string | Nein | Cursor für Paginierung |
-| `sort_field` | string | Nein | Feld zum Sortieren (z. B. "name", "created_at", "last_seen_at") |
-| `sort_order` | string | Nein | Sortierreihenfolge: "ascending" oder "descending" |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `contacts` | array | Array von übereinstimmenden Kontaktobjekten |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Suchergebnisse |
 
 ### `intercom_delete_contact`
 
@@ -152,9 +150,8 @@ Einen Kontakt aus Intercom nach ID löschen
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `id` | string | ID des gelöschten Kontakts |
-| `deleted` | boolean | Ob der Kontakt gelöscht wurde |
-| `metadata` | object | Metadaten der Operation |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Löschergebnis |
 
 ### `intercom_create_company`
 
@@ -166,19 +163,19 @@ Ein Unternehmen in Intercom erstellen oder aktualisieren
 | --------- | ---- | -------- | ----------- |
 | `company_id` | string | Ja | Ihre eindeutige Kennung für das Unternehmen |
 | `name` | string | Nein | Der Name des Unternehmens |
-| `website` | string | Nein | Die Website des Unternehmens |
-| `plan` | string | Nein | Der Name des Unternehmensplans |
+| `website` | string | Nein | Die Unternehmenswebsite |
+| `plan` | string | Nein | Der Unternehmensplan |
 | `size` | number | Nein | Die Anzahl der Mitarbeiter im Unternehmen |
 | `industry` | string | Nein | Die Branche, in der das Unternehmen tätig ist |
-| `monthly_spend` | number | Nein | Wie viel Umsatz das Unternehmen für Ihr Geschäft generiert. Hinweis: Dieses Feld rundet Dezimalzahlen auf ganze Zahlen ab (z. B. wird 155,98 zu 155) |
+| `monthly_spend` | number | Nein | Wie viel Umsatz das Unternehmen für Ihr Geschäft generiert. Hinweis: Dieses Feld kürzt Dezimalzahlen auf ganze Zahlen \(z.B. wird aus 155,98 die Zahl 155\) |
 | `custom_attributes` | string | Nein | Benutzerdefinierte Attribute als JSON-Objekt |
-| `remote_created_at` | number | Nein | Der Zeitpunkt, zu dem das Unternehmen von Ihnen erstellt wurde, als Unix-Zeitstempel |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `company` | object | Erstelltes oder aktualisiertes Unternehmensobjekt |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Erstellte oder aktualisierte Unternehmensdaten |
 
 ### `intercom_get_company`
 
@@ -194,7 +191,8 @@ Ein einzelnes Unternehmen anhand der ID von Intercom abrufen
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `company` | object | Unternehmensobjekt |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Unternehmensdaten |
 
 ### `intercom_list_companies`
 
@@ -206,13 +204,13 @@ Listet alle Unternehmen von Intercom mit Paginierungsunterstützung auf. Hinweis
 | --------- | ---- | -------- | ----------- |
 | `per_page` | number | Nein | Anzahl der Ergebnisse pro Seite |
 | `page` | number | Nein | Seitennummer |
-| `starting_after` | string | Nein | Cursor für Paginierung (bevorzugt gegenüber seitenbasierter Paginierung) |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `companies` | array | Array von Unternehmensobjekten |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Liste der Unternehmen |
 
 ### `intercom_get_conversation`
 
@@ -223,14 +221,14 @@ Eine einzelne Konversation anhand der ID von Intercom abrufen
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `conversationId` | string | Ja | Konversations-ID zum Abrufen |
-| `display_as` | string | Nein | Auf "plaintext" setzen, um Nachrichten als reinen Text abzurufen |
-| `include_translations` | boolean | Nein | Wenn true, werden Konversationsteile in die erkannte Sprache der Konversation übersetzt |
+| `display_as` | string | Nein | Auf "plaintext" setzen, um Nachrichten im Klartext abzurufen |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `conversation` | object | Konversationsobjekt |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Konversationsdaten |
 
 ### `intercom_list_conversations`
 
@@ -240,16 +238,15 @@ Alle Konversationen von Intercom mit Paginierungsunterstützung auflisten
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `per_page` | number | Nein | Anzahl der Ergebnisse pro Seite (max: 150) |
+| `per_page` | number | Nein | Anzahl der Ergebnisse pro Seite \(max: 150\) |
 | `starting_after` | string | Nein | Cursor für Paginierung |
-| `sort` | string | Nein | Feld zum Sortieren (z. B. "waiting_since", "updated_at", "created_at") |
-| `order` | string | Nein | Sortierreihenfolge: "asc" (aufsteigend) oder "desc" (absteigend) |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `conversations` | array | Array von Konversationsobjekten |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Liste der Konversationen |
 
 ### `intercom_reply_conversation`
 
@@ -259,18 +256,18 @@ Als Administrator auf eine Konversation in Intercom antworten
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `conversationId` | string | Ja | Konversations-ID zum Antworten |
+| `conversationId` | string | Ja | Konversations-ID, auf die geantwortet werden soll |
 | `message_type` | string | Ja | Nachrichtentyp: "comment" oder "note" |
 | `body` | string | Ja | Der Textinhalt der Antwort |
-| `admin_id` | string | Nein | Die ID des Administrators, der die Antwort verfasst. Falls nicht angegeben, wird ein Standard-Administrator (Operator/Fin) verwendet. |
-| `attachment_urls` | string | Nein | Kommagetrennte Liste von Bild-URLs (max. 10) |
-| `created_at` | number | Nein | Unix-Zeitstempel für den Zeitpunkt der Erstellung der Antwort. Falls nicht angegeben, wird die aktuelle Zeit verwendet. |
+| `admin_id` | string | Nein | Die ID des Administrators, der die Antwort verfasst. Wenn nicht angegeben, wird ein Standard-Administrator \(Operator/Fin\) verwendet. |
+| `attachment_urls` | string | Nein | Kommagetrennte Liste von Bild-URLs \(max. 10\) |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `conversation` | object | Aktualisiertes Konversationsobjekt |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Aktualisierte Konversation mit Antwort |
 
 ### `intercom_search_conversations`
 
@@ -281,16 +278,15 @@ Nach Konversationen in Intercom mit einer Abfrage suchen
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `query` | string | Ja | Suchabfrage als JSON-Objekt |
-| `per_page` | number | Nein | Anzahl der Ergebnisse pro Seite \(max: 150\) |
+| `per_page` | number | Nein | Anzahl der Ergebnisse pro Seite (max: 150) |
 | `starting_after` | string | Nein | Cursor für Paginierung |
-| `sort_field` | string | Nein | Feld, nach dem sortiert werden soll \(z. B. "created_at", "updated_at"\) |
-| `sort_order` | string | Nein | Sortierreihenfolge: "ascending" oder "descending" |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `conversations` | array | Array von übereinstimmenden Konversationsobjekten |
+| `success` | boolean | Status des Operationserfolgs |
+| `output` | object | Suchergebnisse |
 
 ### `intercom_create_ticket`
 
@@ -301,18 +297,15 @@ Ein neues Ticket in Intercom erstellen
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `ticket_type_id` | string | Ja | Die ID des Ticket-Typs |
-| `contacts` | string | Ja | JSON-Array von Kontaktkennungen \(z. B. \[\{"id": "contact_id"\}\]\) |
+| `contacts` | string | Ja | JSON-Array von Kontakt-Identifikatoren (z.B. \{"id": "contact_id"\}) |
 | `ticket_attributes` | string | Ja | JSON-Objekt mit Ticket-Attributen einschließlich _default_title_ und _default_description_ |
-| `company_id` | string | Nein | Unternehmens-ID, mit der das Ticket verknüpft werden soll |
-| `created_at` | number | Nein | Unix-Zeitstempel für den Zeitpunkt der Ticket-Erstellung. Wenn nicht angegeben, wird die aktuelle Zeit verwendet. |
-| `conversation_to_link_id` | string | Nein | ID einer vorhandenen Konversation, die mit diesem Ticket verknüpft werden soll |
-| `disable_notifications` | boolean | Nein | Wenn true, werden Benachrichtigungen bei der Ticket-Erstellung unterdrückt |
 
 #### Output
 
-| Parameter | Typ | Beschreibung |
+| Parameter | Type | Beschreibung |
 | --------- | ---- | ----------- |
-| `ticket` | object | Erstelltes Ticket-Objekt |
+| `success` | boolean | Erfolgsstatus der Operation |
+| `output` | object | Erstellte Ticket-Daten |
 
 ### `intercom_get_ticket`
 
@@ -326,9 +319,10 @@ Ein einzelnes Ticket anhand der ID von Intercom abrufen
 
 #### Output
 
-| Parameter | Typ | Beschreibung |
+| Parameter | Type | Beschreibung |
 | --------- | ---- | ----------- |
-| `ticket` | object | Ticket-Objekt |
+| `success` | boolean | Erfolgsstatus der Operation |
+| `output` | object | Ticket-Daten |
 
 ### `intercom_create_message`
 
@@ -336,23 +330,22 @@ Eine neue vom Administrator initiierte Nachricht in Intercom erstellen und sende
 
 #### Input
 
-| Parameter | Typ | Erforderlich | Beschreibung |
+| Parameter | Type | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `message_type` | string | Ja | Nachrichtentyp: "inapp" für In-App-Nachrichten oder "email" für E-Mail-Nachrichten |
-| `template` | string | Ja | Nachrichtenvorlagenstil: "plain" für einfachen Text oder "personal" für personalisierten Stil |
+| `message_type` | string | Ja | Nachrichtentyp: "inapp" oder "email" |
 | `subject` | string | Nein | Der Betreff der Nachricht \(für E-Mail-Typ\) |
 | `body` | string | Ja | Der Inhalt der Nachricht |
 | `from_type` | string | Ja | Absendertyp: "admin" |
 | `from_id` | string | Ja | Die ID des Administrators, der die Nachricht sendet |
 | `to_type` | string | Ja | Empfängertyp: "contact" |
 | `to_id` | string | Ja | Die ID des Kontakts, der die Nachricht empfängt |
-| `created_at` | number | Nein | Unix-Zeitstempel für den Zeitpunkt der Nachrichtenerstellung. Wenn nicht angegeben, wird die aktuelle Zeit verwendet. |
 
 #### Output
 
-| Parameter | Typ | Beschreibung |
+| Parameter | Type | Beschreibung |
 | --------- | ---- | ----------- |
-| `message` | object | Erstelltes Nachrichtenobjekt |
+| `success` | boolean | Erfolgsstatus der Operation |
+| `output` | object | Erstellte Nachrichtendaten |
 
 ## Notizen
 

apps/docs/content/docs/de/tools/jina.mdx

@@ -61,6 +61,8 @@ Extrahieren und verarbeiten Sie Webinhalte in sauberen, LLM-freundlichen Text mi
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
 | `content` | string | Der extrahierte Inhalt von der URL, verarbeitet zu sauberem, LLM-freundlichem Text |
+| `links` | array | Liste der auf der Seite gefundenen Links (wenn gatherLinks oder withLinksummary aktiviert ist) |
+| `images` | array | Liste der auf der Seite gefundenen Bilder (wenn withImagesummary aktiviert ist) |
 
 ### `jina_search`
 

apps/docs/content/docs/de/tools/jira_service_management.mdx

@@ -1,486 +0,0 @@
----
-title: Jira Service Management
-description: Interagieren Sie mit Jira Service Management
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="jira_service_management"
-  color="#E0E0E0"
-/>
-
-## Nutzungsanweisungen
-
-Integrieren Sie Jira Service Management für IT-Service-Management. Erstellen und verwalten Sie Service-Anfragen, bearbeiten Sie Kunden und Organisationen, verfolgen Sie SLAs und verwalten Sie Warteschlangen.
-
-## Tools
-
-### `jsm_get_service_desks`
-
-Alle Service Desks aus Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `serviceDesks` | json | Array von Service Desks |
-| `total` | number | Gesamtanzahl der Service Desks |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_get_request_types`
-
-Anfragetypen für einen Service Desk in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service Desk ID, für die Anfragetypen abgerufen werden sollen |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `requestTypes` | json | Array von Anfragetypen |
-| `total` | number | Gesamtanzahl der Anfragetypen |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_create_request`
-
-Erstellen Sie eine neue Serviceanfrage in Jira Service Management
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service-Desk-ID, in der die Anfrage erstellt werden soll |
-| `requestTypeId` | string | Ja | Anfragetyp-ID für die neue Anfrage |
-| `summary` | string | Ja | Zusammenfassung/Titel für die Serviceanfrage |
-| `description` | string | Nein | Beschreibung für die Serviceanfrage |
-| `raiseOnBehalfOf` | string | Nein | Konto-ID des Kunden, für den die Anfrage im Namen gestellt werden soll |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueId` | string | Erstellte Anfrage-Issue-ID |
-| `issueKey` | string | Erstellter Anfrage-Issue-Key \(z. B. SD-123\) |
-| `requestTypeId` | string | Anfragetyp-ID |
-| `serviceDeskId` | string | Service-Desk-ID |
-| `success` | boolean | Ob die Anfrage erfolgreich erstellt wurde |
-| `url` | string | URL zur erstellten Anfrage |
-
-### `jsm_get_request`
-
-Eine einzelne Serviceanfrage aus Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-
-### `jsm_get_requests`
-
-Mehrere Serviceanfragen aus Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `serviceDeskId` | string | Nein | Nach Service-Desk-ID filtern |
-| `requestOwnership` | string | Nein | Nach Eigentümerschaft filtern: OWNED_REQUESTS, PARTICIPATED_REQUESTS, ORGANIZATION, ALL_REQUESTS |
-| `requestStatus` | string | Nein | Nach Status filtern: OPEN, CLOSED, ALL |
-| `searchTerm` | string | Nein | Suchbegriff zum Filtern von Anfragen |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `requests` | json | Array von Serviceanfragen |
-| `total` | number | Gesamtanzahl der Anfragen |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_add_comment`
-
-Einen Kommentar (öffentlich oder intern) zu einer Serviceanfrage in Jira Service Management hinzufügen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-| `body` | string | Ja | Kommentartext |
-| `isPublic` | boolean | Ja | Ob der Kommentar öffentlich \(für Kunden sichtbar\) oder intern ist |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Vorgangs-ID oder -Schlüssel |
-| `commentId` | string | ID des erstellten Kommentars |
-| `body` | string | Kommentartext |
-| `isPublic` | boolean | Ob der Kommentar öffentlich ist |
-| `success` | boolean | Ob der Kommentar erfolgreich hinzugefügt wurde |
-
-### `jsm_get_comments`
-
-Kommentare für eine Serviceanfrage in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-| `isPublic` | boolean | Nein | Nur öffentliche Kommentare filtern |
-| `internal` | boolean | Nein | Nur interne Kommentare filtern |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Vorgangs-ID oder -Schlüssel |
-| `comments` | json | Array von Kommentaren |
-| `total` | number | Gesamtanzahl der Kommentare |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_get_customers`
-
-Kunden für einen Service Desk in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service-Desk-ID, für die Kunden abgerufen werden sollen |
-| `query` | string | Nein | Suchabfrage zum Filtern von Kunden |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `customers` | json | Array von Kunden |
-| `total` | number | Gesamtanzahl der Kunden |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_add_customer`
-
-Kunden zu einem Service Desk in Jira Service Management hinzufügen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service-Desk-ID, zu der Kunden hinzugefügt werden sollen |
-| `emails` | string | Ja | Kommagetrennte E-Mail-Adressen, die als Kunden hinzugefügt werden sollen |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `serviceDeskId` | string | Service-Desk-ID |
-| `success` | boolean | Ob Kunden erfolgreich hinzugefügt wurden |
-
-### `jsm_get_organizations`
-
-Organisationen für einen Service Desk in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service-Desk-ID, für die Organisationen abgerufen werden sollen |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `organizations` | json | Array von Organisationen |
-| `total` | number | Gesamtanzahl der Organisationen |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_create_organization`
-
-Eine neue Organisation in Jira Service Management erstellen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `name` | string | Ja | Name der zu erstellenden Organisation |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `organizationId` | string | ID der erstellten Organisation |
-| `name` | string | Name der erstellten Organisation |
-| `success` | boolean | Ob die Operation erfolgreich war |
-
-### `jsm_add_organization`
-
-Eine Organisation zu einem Service Desk in Jira Service Management hinzufügen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service Desk ID, zu der die Organisation hinzugefügt werden soll |
-| `organizationId` | string | Ja | Organisations-ID, die zum Service Desk hinzugefügt werden soll |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `serviceDeskId` | string | Service Desk ID |
-| `organizationId` | string | Hinzugefügte Organisations-ID |
-| `success` | boolean | Ob die Operation erfolgreich war |
-
-### `jsm_get_queues`
-
-Warteschlangen für einen Service Desk in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `serviceDeskId` | string | Ja | Service Desk ID, für die Warteschlangen abgerufen werden sollen |
-| `includeCount` | boolean | Nein | Vorgangsanzahl für jede Warteschlange einbeziehen |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `queues` | json | Array von Warteschlangen |
-| `total` | number | Gesamtanzahl der Warteschlangen |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_get_sla`
-
-SLA-Informationen für eine Serviceanfrage in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Vorgangs-ID oder -Schlüssel |
-| `slas` | json | Array mit SLA-Informationen |
-| `total` | number | Gesamtanzahl der SLAs |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_get_transitions`
-
-Verfügbare Übergänge für eine Serviceanfrage in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Vorgangs-ID oder -Schlüssel |
-| `transitions` | json | Array mit verfügbaren Übergängen |
-
-### `jsm_transition_request`
-
-Eine Serviceanfrage in einen neuen Status in Jira Service Management überführen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-| `transitionId` | string | Ja | Anzuwendende Übergangs-ID |
-| `comment` | string | Nein | Optionaler Kommentar, der während des Übergangs hinzugefügt werden kann |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Issue-ID oder -Schlüssel |
-| `transitionId` | string | Angewendete Übergangs-ID |
-| `success` | boolean | Ob der Übergang erfolgreich war |
-
-### `jsm_get_participants`
-
-Teilnehmer für eine Anfrage in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Issue-ID oder -Schlüssel \(z. B. SD-123\) |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Issue-ID oder -Schlüssel |
-| `participants` | json | Array von Teilnehmern |
-| `total` | number | Gesamtanzahl der Teilnehmer |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_add_participants`
-
-Teilnehmer zu einer Anfrage in Jira Service Management hinzufügen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Issue-ID oder -Schlüssel \(z. B. SD-123\) |
-| `accountIds` | string | Ja | Durch Kommas getrennte Account-IDs, die als Teilnehmer hinzugefügt werden sollen |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Vorgangs-ID oder -Schlüssel |
-| `participants` | json | Array der hinzugefügten Teilnehmer |
-| `success` | boolean | Ob die Operation erfolgreich war |
-
-### `jsm_get_approvals`
-
-Genehmigungen für eine Anfrage in Jira Service Management abrufen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-| `start` | number | Nein | Startindex für Paginierung \(Standard: 0\) |
-| `limit` | number | Nein | Maximale Anzahl zurückzugebender Ergebnisse \(Standard: 50\) |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Vorgangs-ID oder -Schlüssel |
-| `approvals` | json | Array der Genehmigungen |
-| `total` | number | Gesamtanzahl der Genehmigungen |
-| `isLastPage` | boolean | Ob dies die letzte Seite ist |
-
-### `jsm_answer_approval`
-
-Eine Genehmigungsanfrage in Jira Service Management genehmigen oder ablehnen
-
-#### Eingabe
-
-| Parameter | Typ | Erforderlich | Beschreibung |
-| --------- | ---- | -------- | ----------- |
-| `domain` | string | Ja | Ihre Jira-Domain \(z. B. ihrfirma.atlassian.net\) |
-| `cloudId` | string | Nein | Jira Cloud-ID für die Instanz |
-| `issueIdOrKey` | string | Ja | Vorgangs-ID oder -Schlüssel \(z. B. SD-123\) |
-| `approvalId` | string | Ja | Genehmigungs-ID zur Beantwortung |
-| `decision` | string | Ja | Entscheidung: "approve" oder "decline" |
-
-#### Ausgabe
-
-| Parameter | Typ | Beschreibung |
-| --------- | ---- | ----------- |
-| `ts` | string | Zeitstempel der Operation |
-| `issueIdOrKey` | string | Issue-ID oder -Schlüssel |
-| `approvalId` | string | Genehmigungs-ID |
-| `decision` | string | Getroffene Entscheidung \(genehmigen/ablehnen\) |
-| `success` | boolean | Ob die Operation erfolgreich war |
-
-## Hinweise
-
-- Kategorie: `tools`
-- Typ: `jira_service_management`

apps/docs/content/docs/de/tools/kalshi.mdx

@@ -123,6 +123,8 @@ Kontostand und Portfoliowert von Kalshi abrufen
 | --------- | ---- | ----------- |
 | `balance` | number | Kontostand in Cent |
 | `portfolioValue` | number | Portfoliowert in Cent |
+| `balanceDollars` | number | Kontostand in Dollar |
+| `portfolioValueDollars` | number | Portfoliowert in Dollar |
 
 ### `kalshi_get_positions`
 

apps/docs/content/docs/de/tools/memory.mdx

@@ -10,52 +10,55 @@ import { BlockInfoCard } from "@/components/ui/block-info-card"
   color="#F64F9E"
 />
 
-## Nutzungsanweisungen
+## Gebrauchsanweisung
 
-Integrieren Sie Memory in den Workflow. Kann Erinnerungen hinzufügen, abrufen, alle Erinnerungen abrufen und Erinnerungen löschen.
+Memory in den Workflow integrieren. Kann Erinnerungen hinzufügen, eine Erinnerung abrufen, alle Erinnerungen abrufen und Erinnerungen löschen.
 
 ## Tools
 
 ### `memory_add`
 
-Fügen Sie eine neue Erinnerung zur Datenbank hinzu oder hängen Sie sie an eine bestehende Erinnerung mit derselben ID an.
+Füge eine neue Erinnerung zur Datenbank hinzu oder ergänze bestehende Erinnerungen mit derselben ID.
 
 #### Eingabe
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `conversationId` | string | Nein | Konversationskennung \(z. B. user-123, session-abc\). Wenn bereits eine Erinnerung mit dieser conversationId existiert, wird die neue Nachricht an diese angehängt. |
-| `id` | string | Nein | Legacy-Parameter für Konversationskennung. Verwenden Sie stattdessen conversationId. Wird aus Gründen der Abwärtskompatibilität bereitgestellt. |
-| `role` | string | Ja | Rolle für Agent-Erinnerung \(user, assistant oder system\) |
+| `conversationId` | string | Nein | Konversationskennung (z.B. user-123, session-abc). Wenn bereits eine Erinnerung mit dieser conversationId für diesen Block existiert, wird die neue Nachricht angehängt. |
+| `id` | string | Nein | Legacy-Parameter für die Konversationskennung. Verwenden Sie stattdessen conversationId. Für Abwärtskompatibilität bereitgestellt. |
+| `role` | string | Ja | Rolle für Agent-Erinnerung (user, assistant oder system) |
 | `content` | string | Ja | Inhalt für Agent-Erinnerung |
+| `blockId` | string | Nein | Optionale Block-ID. Wenn nicht angegeben, wird die aktuelle Block-ID aus dem Ausführungskontext verwendet oder standardmäßig "default" gesetzt. |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `success` | boolean | Ob die Erinnerung erfolgreich hinzugefügt wurde |
-| `memories` | array | Array von Erinnerungsobjekten einschließlich der neuen oder aktualisierten Erinnerung |
+| `success` | boolean | Ob der Speicher erfolgreich hinzugefügt wurde |
+| `memories` | array | Array von Speicherobjekten einschließlich des neuen oder aktualisierten Speichers |
 | `error` | string | Fehlermeldung, falls der Vorgang fehlgeschlagen ist |
 
 ### `memory_get`
 
-Erinnerung nach conversationId abrufen. Gibt übereinstimmende Erinnerungen zurück.
+Erinnerungen nach conversationId, blockId, blockName oder einer Kombination abrufen. Gibt alle übereinstimmenden Erinnerungen zurück.
 
 #### Eingabe
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `conversationId` | string | Nein | Konversationskennung \(z. B. user-123, session-abc\). Gibt Erinnerungen für diese Konversation zurück. |
-| `id` | string | Nein | Legacy-Parameter für Konversationskennung. Verwenden Sie stattdessen conversationId. Wird aus Gründen der Abwärtskompatibilität bereitgestellt. |
+| `conversationId` | string | Nein | Konversationskennung (z.B. user-123, session-abc). Wenn allein angegeben, werden alle Erinnerungen für diese Konversation über alle Blöcke hinweg zurückgegeben. |
+| `id` | string | Nein | Legacy-Parameter für die Konversationskennung. Verwenden Sie stattdessen conversationId. Für Abwärtskompatibilität bereitgestellt. |
+| `blockId` | string | Nein | Block-Kennung. Wenn allein angegeben, werden alle Erinnerungen für diesen Block über alle Konversationen hinweg zurückgegeben. Wenn mit conversationId angegeben, werden Erinnerungen für diese spezifische Konversation in diesem Block zurückgegeben. |
+| `blockName` | string | Nein | Blockname. Alternative zu blockId. Wenn allein angegeben, werden alle Erinnerungen für Blöcke mit diesem Namen zurückgegeben. Wenn mit conversationId angegeben, werden Erinnerungen für diese Konversation in Blöcken mit diesem Namen zurückgegeben. |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `success` | boolean | Ob der Speicher erfolgreich abgerufen wurde |
-| `memories` | array | Array von Speicherobjekten mit conversationId- und data-Feldern |
+| `success` | boolean | Ob die Erinnerung erfolgreich abgerufen wurde |
+| `memories` | array | Array von Speicherobjekten mit conversationId, blockId, blockName und data-Feldern |
 | `message` | string | Erfolgs- oder Fehlermeldung |
-| `error` | string | Fehlermeldung, falls fehlgeschlagen |
+| `error` | string | Fehlermeldung, wenn der Vorgang fehlgeschlagen ist |
 
 ### `memory_get_all`
 
@@ -70,29 +73,31 @@ Alle Speicher aus der Datenbank abrufen
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `success` | boolean | Ob alle Speicher erfolgreich abgerufen wurden |
-| `memories` | array | Array aller Speicherobjekte mit key-, conversationId- und data-Feldern |
+| `success` | boolean | Ob alle Erinnerungen erfolgreich abgerufen wurden |
+| `memories` | array | Array aller Speicherobjekte mit key, conversationId, blockId, blockName und data-Feldern |
 | `message` | string | Erfolgs- oder Fehlermeldung |
-| `error` | string | Fehlermeldung, falls fehlgeschlagen |
+| `error` | string | Fehlermeldung, wenn der Vorgang fehlgeschlagen ist |
 
 ### `memory_delete`
 
-Speicher nach conversationId löschen.
+Löschen von Erinnerungen nach conversationId, blockId, blockName oder einer Kombination davon. Unterstützt Massenlöschung.
 
 #### Eingabe
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `conversationId` | string | Nein | Konversationskennung (z. B. user-123, session-abc). Löscht alle Speicher für diese Konversation. |
-| `id` | string | Nein | Legacy-Parameter für Konversationskennung. Verwenden Sie stattdessen conversationId. Wird aus Gründen der Abwärtskompatibilität bereitgestellt. |
+| `conversationId` | string | Nein | Konversationskennung (z.B. user-123, session-abc). Wenn allein angegeben, werden alle Erinnerungen für diese Konversation über alle Blöcke hinweg gelöscht. |
+| `id` | string | Nein | Legacy-Parameter für die Konversationskennung. Verwenden Sie stattdessen conversationId. Für Abwärtskompatibilität bereitgestellt. |
+| `blockId` | string | Nein | Block-Kennung. Wenn allein angegeben, werden alle Erinnerungen für diesen Block über alle Konversationen hinweg gelöscht. Wenn mit conversationId angegeben, werden Erinnerungen für diese spezifische Konversation in diesem Block gelöscht. |
+| `blockName` | string | Nein | Blockname. Alternative zu blockId. Wenn allein angegeben, werden alle Erinnerungen für Blöcke mit diesem Namen gelöscht. Wenn mit conversationId angegeben, werden Erinnerungen für diese Konversation in Blöcken mit diesem Namen gelöscht. |
 
 #### Ausgabe
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `success` | boolean | Ob der Speicher erfolgreich gelöscht wurde |
+| `success` | boolean | Ob die Erinnerung erfolgreich gelöscht wurde |
 | `message` | string | Erfolgs- oder Fehlermeldung |
-| `error` | string | Fehlermeldung, falls fehlgeschlagen |
+| `error` | string | Fehlermeldung, wenn der Vorgang fehlgeschlagen ist |
 
 ## Hinweise
 

apps/docs/content/docs/de/tools/pinecone.mdx

@@ -70,7 +70,8 @@ Text-Datensätze in einen Pinecone-Index einfügen oder aktualisieren
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `statusText` | string | Status der Upsert-Operation |
+| `statusText` | string | Status des Einfügevorgangs |
+| `upsertedCount` | number | Anzahl der erfolgreich eingefügten Datensätze |
 
 ### `pinecone_search_text`
 

apps/docs/content/docs/de/tools/slack.mdx

@@ -109,12 +109,12 @@ Lesen Sie die neuesten Nachrichten aus Slack-Kanälen. Rufen Sie den Konversatio
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `authMethod` | string | Nein | Authentifizierungsmethode: oauth oder bot_token |
-| `botToken` | string | Nein | Bot-Token für Custom Bot |
+| `botToken` | string | Nein | Bot-Token für benutzerdefinierten Bot |
 | `channel` | string | Nein | Slack-Kanal, aus dem Nachrichten gelesen werden sollen \(z.B. #general\) |
 | `userId` | string | Nein | Benutzer-ID für DM-Konversation \(z.B. U1234567890\) |
-| `limit` | number | Nein | Anzahl der abzurufenden Nachrichten \(Standard: 10, max: 15\) |
-| `oldest` | string | Nein | Beginn des Zeitbereichs \(Zeitstempel\) |
-| `latest` | string | Nein | Ende des Zeitbereichs \(Zeitstempel\) |
+| `limit` | number | Nein | Anzahl der abzurufenden Nachrichten \(Standard: 10, max: 100\) |
+| `oldest` | string | Nein | Beginn des Zeitraums \(Zeitstempel\) |
+| `latest` | string | Nein | Ende des Zeitraums \(Zeitstempel\) |
 
 #### Ausgabe
 

apps/docs/content/docs/de/tools/supabase.mdx

@@ -49,12 +49,10 @@ Daten aus einer Supabase-Tabelle abfragen
 | --------- | ---- | -------- | ----------- |
 | `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
 | `table` | string | Ja | Der Name der abzufragenden Supabase-Tabelle |
-| `schema` | string | Nein | Datenbankschema für die Abfrage \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
-| `select` | string | Nein | Zurückzugebende Spalten \(durch Komma getrennt\). Standard ist * \(alle Spalten\) |
 | `filter` | string | Nein | PostgREST-Filter \(z.B. "id=eq.123"\) |
-| `orderBy` | string | Nein | Spalte zum Sortieren \(fügen Sie DESC für absteigende Sortierung hinzu\) |
+| `orderBy` | string | Nein | Spalte zum Sortieren \(fügen Sie DESC für absteigend hinzu\) |
 | `limit` | number | Nein | Maximale Anzahl der zurückzugebenden Zeilen |
-| `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
+| `apiKey` | string | Ja | Ihr Supabase Service-Rolle-Secret-Schlüssel |
 
 #### Ausgabe
 
@@ -71,9 +69,8 @@ Daten in eine Supabase-Tabelle einfügen
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z. B. jdrkgepadsdopsntdlom\) |
+| `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
 | `table` | string | Ja | Der Name der Supabase-Tabelle, in die Daten eingefügt werden sollen |
-| `schema` | string | Nein | Datenbankschema für das Einfügen \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
 | `data` | array | Ja | Die einzufügenden Daten \(Array von Objekten oder ein einzelnes Objekt\) |
 | `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
 
@@ -92,12 +89,10 @@ Eine einzelne Zeile aus einer Supabase-Tabelle basierend auf Filterkriterien abr
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
-| `table` | string | Ja | Der Name der abzufragenden Supabase-Tabelle |
-| `schema` | string | Nein | Datenbankschema für die Abfrage \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
-| `select` | string | Nein | Zurückzugebende Spalten \(durch Komma getrennt\). Standard ist * \(alle Spalten\) |
-| `filter` | string | Ja | PostgREST-Filter zum Finden der spezifischen Zeile \(z.B. "id=eq.123"\) |
-| `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
+| `projectId` | string | Ja | Ihre Supabase-Projekt-ID (z.B. jdrkgepadsdopsntdlom) |
+| `table` | string | Ja | Der Name der Supabase-Tabelle für die Abfrage |
+| `filter` | string | Ja | PostgREST-Filter zum Finden der spezifischen Zeile (z.B. "id=eq.123") |
+| `apiKey` | string | Ja | Ihr Supabase Service-Role-Secret-Key |
 
 #### Ausgabe
 
@@ -114,10 +109,9 @@ Zeilen in einer Supabase-Tabelle basierend auf Filterkriterien aktualisieren
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
+| `projectId` | string | Ja | Ihre Supabase-Projekt-ID (z.B. jdrkgepadsdopsntdlom) |
 | `table` | string | Ja | Der Name der zu aktualisierenden Supabase-Tabelle |
-| `schema` | string | Nein | Datenbankschema für die Aktualisierung \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
-| `filter` | string | Ja | PostgREST-Filter zur Identifizierung der zu aktualisierenden Zeilen \(z.B. "id=eq.123"\) |
+| `filter` | string | Ja | PostgREST-Filter zur Identifizierung der zu aktualisierenden Zeilen (z.B. "id=eq.123") |
 | `data` | object | Ja | Daten, die in den übereinstimmenden Zeilen aktualisiert werden sollen |
 | `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
 
@@ -136,10 +130,9 @@ Zeilen aus einer Supabase-Tabelle basierend auf Filterkriterien löschen
 
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
-| `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
+| `projectId` | string | Ja | Ihre Supabase-Projekt-ID (z.B. jdrkgepadsdopsntdlom) |
 | `table` | string | Ja | Der Name der Supabase-Tabelle, aus der gelöscht werden soll |
-| `schema` | string | Nein | Datenbankschema für die Löschung \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
-| `filter` | string | Ja | PostgREST-Filter zur Identifizierung der zu löschenden Zeilen \(z.B. "id=eq.123"\) |
+| `filter` | string | Ja | PostgREST-Filter zur Identifizierung der zu löschenden Zeilen (z.B. "id=eq.123") |
 | `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
 
 #### Ausgabe
@@ -158,9 +151,8 @@ Daten in eine Supabase-Tabelle einfügen oder aktualisieren (Upsert-Operation)
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
-| `table` | string | Ja | Der Name der Supabase-Tabelle, in die Daten eingefügt oder aktualisiert werden sollen |
-| `schema` | string | Nein | Datenbankschema für Upsert \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
-| `data` | array | Ja | Die Daten für Upsert \(Einfügen oder Aktualisieren\) - Array von Objekten oder ein einzelnes Objekt |
+| `table` | string | Ja | Der Name der Supabase-Tabelle, in die Daten upsertet werden sollen |
+| `data` | array | Ja | Die zu upsertenden Daten \(einfügen oder aktualisieren\) - Array von Objekten oder ein einzelnes Objekt |
 | `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
 
 #### Ausgabe
@@ -179,8 +171,7 @@ Zeilen in einer Supabase-Tabelle zählen
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
-| `table` | string | Ja | Der Name der Supabase-Tabelle, aus der Zeilen gezählt werden sollen |
-| `schema` | string | Nein | Datenbankschema zum Zählen \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
+| `table` | string | Ja | Der Name der Supabase-Tabelle, deren Zeilen gezählt werden sollen |
 | `filter` | string | Nein | PostgREST-Filter \(z.B. "status=eq.active"\) |
 | `countType` | string | Nein | Zähltyp: exact, planned oder estimated \(Standard: exact\) |
 | `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
@@ -201,8 +192,7 @@ Volltextsuche in einer Supabase-Tabelle durchführen
 | Parameter | Typ | Erforderlich | Beschreibung |
 | --------- | ---- | -------- | ----------- |
 | `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
-| `table` | string | Ja | Der Name der zu durchsuchenden Supabase-Tabelle |
-| `schema` | string | Nein | Datenbankschema zum Durchsuchen \(Standard: public\). Verwenden Sie dies, um auf Tabellen in anderen Schemas zuzugreifen. |
+| `table` | string | Ja | Der Name der Supabase-Tabelle für die Suche |
 | `column` | string | Ja | Die Spalte, in der gesucht werden soll |
 | `query` | string | Ja | Die Suchanfrage |
 | `searchType` | string | Nein | Suchtyp: plain, phrase oder websearch \(Standard: websearch\) |
@@ -268,11 +258,10 @@ Eine Datei in einen Supabase-Speicher-Bucket hochladen
 | --------- | ---- | -------- | ----------- |
 | `projectId` | string | Ja | Ihre Supabase-Projekt-ID \(z.B. jdrkgepadsdopsntdlom\) |
 | `bucket` | string | Ja | Der Name des Speicher-Buckets |
-| `fileName` | string | Ja | Der Name der Datei \(z.B. "dokument.pdf", "bild.jpg"\) |
-| `path` | string | Nein | Optionaler Ordnerpfad \(z.B. "ordner/unterordner/"\) |
+| `path` | string | Ja | Der Pfad, unter dem die Datei gespeichert wird \(z.B. "ordner/datei.jpg"\) |
 | `fileContent` | string | Ja | Der Dateiinhalt \(base64-kodiert für Binärdateien oder Klartext\) |
 | `contentType` | string | Nein | MIME-Typ der Datei \(z.B. "image/jpeg", "text/plain"\) |
-| `upsert` | boolean | Nein | Wenn true, wird die vorhandene Datei überschrieben \(Standard: false\) |
+| `upsert` | boolean | Nein | Wenn true, überschreibt vorhandene Datei \(Standard: false\) |
 | `apiKey` | string | Ja | Ihr Supabase Service Role Secret Key |
 
 #### Ausgabe

apps/docs/content/docs/de/tools/translate.mdx

@@ -42,14 +42,13 @@ Senden Sie eine Chat-Completion-Anfrage an jeden unterstützten LLM-Anbieter
 | `model` | string | Ja | Das zu verwendende Modell \(z. B. gpt-4o, claude-sonnet-4-5, gemini-2.0-flash\) |
 | `systemPrompt` | string | Nein | System-Prompt zur Festlegung des Verhaltens des Assistenten |
 | `context` | string | Ja | Die Benutzernachricht oder der Kontext, der an das Modell gesendet werden soll |
-| `apiKey` | string | Nein | API-Schlüssel für den Anbieter \(verwendet den Plattformschlüssel, falls nicht für gehostete Modelle angegeben\) |
-| `temperature` | number | Nein | Temperatur für die Antwortgenerierung \(0–2\) |
+| `apiKey` | string | Nein | API-Schlüssel für den Anbieter \(verwendet Plattform-Schlüssel, falls nicht für gehostete Modelle angegeben\) |
+| `temperature` | number | Nein | Temperatur für die Antwortgenerierung \(0-2\) |
 | `maxTokens` | number | Nein | Maximale Anzahl von Tokens in der Antwort |
 | `azureEndpoint` | string | Nein | Azure OpenAI-Endpunkt-URL |
 | `azureApiVersion` | string | Nein | Azure OpenAI-API-Version |
 | `vertexProject` | string | Nein | Google Cloud-Projekt-ID für Vertex AI |
 | `vertexLocation` | string | Nein | Google Cloud-Standort für Vertex AI \(Standard: us-central1\) |
-| `vertexCredential` | string | Nein | Google Cloud OAuth-Anmeldeinformations-ID für Vertex AI |
 
 #### Ausgabe
 

apps/docs/content/docs/de/tools/typeform.mdx

@@ -129,18 +129,15 @@ Vollständige Details und Struktur eines bestimmten Formulars abrufen
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `id` | string | Eindeutige Formularkennung |
+| `id` | string | Eindeutige Formular-ID |
 | `title` | string | Formulartitel |
 | `type` | string | Formulartyp \(form, quiz, etc.\) |
 | `settings` | object | Formulareinstellungen einschließlich Sprache, Fortschrittsbalken, etc. |
 | `theme` | object | Theme-Referenz |
 | `workspace` | object | Workspace-Referenz |
 | `fields` | array | Array von Formularfeldern/Fragen |
-| `welcome_screens` | array | Array von Willkommensbildschirmen \(leer, wenn keine konfiguriert\) |
-| `thankyou_screens` | array | Array von Danke-Bildschirmen |
-| `created_at` | string | Zeitstempel der Formularerstellung \(ISO-8601-Format\) |
-| `last_updated_at` | string | Zeitstempel der letzten Formularaktualisierung \(ISO-8601-Format\) |
-| `published_at` | string | Zeitstempel der Formularveröffentlichung \(ISO-8601-Format\) |
+| `welcome_screens` | array | Array von Begrüßungsbildschirmen |
+| `thankyou_screens` | array | Array von Dankesbildschirmen |
 | `_links` | object | Links zu verwandten Ressourcen einschließlich öffentlicher Formular-URL |
 
 ### `typeform_create_form`
@@ -166,12 +163,7 @@ Ein neues Formular mit Feldern und Einstellungen erstellen
 | `id` | string | Eindeutige Kennung des erstellten Formulars |
 | `title` | string | Formulartitel |
 | `type` | string | Formulartyp |
-| `settings` | object | Formulareinstellungsobjekt |
-| `theme` | object | Theme-Referenz |
-| `workspace` | object | Workspace-Referenz |
-| `fields` | array | Array von erstellten Formularfeldern \(leer, wenn keine hinzugefügt\) |
-| `welcome_screens` | array | Array von Willkommensbildschirmen \(leer, wenn keine konfiguriert\) |
-| `thankyou_screens` | array | Array von Danke-Bildschirmen |
+| `fields` | array | Array der erstellten Formularfelder |
 | `_links` | object | Links zu verwandten Ressourcen einschließlich öffentlicher Formular-URL |
 
 ### `typeform_update_form`
@@ -190,7 +182,16 @@ Ein bestehendes Formular mit JSON Patch-Operationen aktualisieren
 
 | Parameter | Typ | Beschreibung |
 | --------- | ---- | ----------- |
-| `message` | string | Erfolgsbestätigungsnachricht |
+| `id` | string | Eindeutige Kennung des aktualisierten Formulars |
+| `title` | string | Formulartitel |
+| `type` | string | Formulartyp |
+| `settings` | object | Formulareinstellungen |
+| `theme` | object | Theme-Referenz |
+| `workspace` | object | Workspace-Referenz |
+| `fields` | array | Array von Formularfeldern |
+| `welcome_screens` | array | Array von Begrüßungsbildschirmen |
+| `thankyou_screens` | array | Array von Dankesbildschirmen |
+| `_links` | object | Links zu verwandten Ressourcen |
 
 ### `typeform_delete_form`
 

apps/docs/content/docs/de/triggers/index.mdx

@@ -22,7 +22,7 @@ Verwende den Start-Block für alles, was aus dem Editor, deploy-to-API oder depl
 
 <Cards>
   <Card title="Start" href="/triggers/start">
-    Einheitlicher Einstiegspunkt, der Editor-Ausführungen, API-Deployments und Chat-Deployments unterstützt
+    Einheitlicher Einstiegspunkt, der Editor-Ausführungen, API-Bereitstellungen und Chat-Bereitstellungen unterstützt
   </Card>
   <Card title="Webhook" href="/triggers/webhook">
     Externe Webhook-Payloads empfangen
@@ -33,9 +33,6 @@ Verwende den Start-Block für alles, was aus dem Editor, deploy-to-API oder depl
   <Card title="RSS Feed" href="/triggers/rss">
     RSS- und Atom-Feeds auf neue Inhalte überwachen
   </Card>
-  <Card title="Email Polling Groups" href="#email-polling-groups">
-    Team-Gmail- und Outlook-Postfächer überwachen
-  </Card>
 </Cards>
 
 ## Schneller Vergleich
@@ -46,7 +43,6 @@ Verwende den Start-Block für alles, was aus dem Editor, deploy-to-API oder depl
 | **Schedule** | Timer, der im Schedule-Block verwaltet wird |
 | **Webhook** | Bei eingehender HTTP-Anfrage |
 | **RSS Feed** | Neues Element im Feed veröffentlicht |
-| **Email Polling Groups** | Neue E-Mail in Team-Gmail- oder Outlook-Postfächern empfangen |
 
 > Der Start-Block stellt immer `input`, `conversationId` und `files` Felder bereit. Füge benutzerdefinierte Felder zum Eingabeformat für zusätzliche strukturierte Daten hinzu.
 
@@ -69,25 +65,3 @@ Wenn du im Editor auf **Run** klickst, wählt Sim automatisch aus, welcher Trigg
 Wenn dein Workflow mehrere Trigger hat, wird der Trigger mit der höchsten Priorität ausgeführt. Wenn du beispielsweise sowohl einen Start-Block als auch einen Webhook-Trigger hast, wird beim Klicken auf Run der Start-Block ausgeführt.
 
 **Externe Auslöser mit Mock-Payloads**: Wenn externe Auslöser (Webhooks und Integrationen) manuell ausgeführt werden, generiert Sim automatisch Mock-Payloads basierend auf der erwarteten Datenstruktur des Auslösers. Dies stellt sicher, dass nachgelagerte Blöcke während des Testens Variablen korrekt auflösen können.
-
-## E-Mail-Polling-Gruppen
-
-Polling-Gruppen ermöglichen es Ihnen, die Gmail- oder Outlook-Postfächer mehrerer Teammitglieder mit einem einzigen Trigger zu überwachen. Erfordert einen Team- oder Enterprise-Plan.
-
-**Erstellen einer Polling-Gruppe** (Admin/Owner)
-
-1. Gehen Sie zu **Einstellungen → E-Mail-Polling**
-2. Klicken Sie auf **Erstellen** und wählen Sie Gmail oder Outlook
-3. Geben Sie einen Namen für die Gruppe ein
-
-**Mitglieder einladen**
-
-1. Klicken Sie auf **Mitglieder hinzufügen** bei Ihrer Polling-Gruppe
-2. Geben Sie E-Mail-Adressen ein (durch Komma oder Zeilenumbruch getrennt oder ziehen Sie eine CSV-Datei per Drag & Drop)
-3. Klicken Sie auf **Einladungen senden**
-
-Eingeladene erhalten eine E-Mail mit einem Link, um ihr Konto zu verbinden. Sobald die Verbindung hergestellt ist, wird ihr Postfach automatisch in die Polling-Gruppe aufgenommen. Eingeladene müssen keine Mitglieder Ihrer Sim-Organisation sein.
-
-**Verwendung in einem Workflow**
-
-Wählen Sie beim Konfigurieren eines E-Mail-Triggers Ihre Polling-Gruppe aus dem Dropdown-Menü für Anmeldeinformationen anstelle eines einzelnen Kontos aus. Das System erstellt Webhooks für jedes Mitglied und leitet alle E-Mails durch Ihren Workflow.

apps/docs/content/docs/de/triggers/schedule.mdx

@@ -5,6 +5,7 @@ title: Zeitplan
 import { Callout } from 'fumadocs-ui/components/callout'
 import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
 import { Image } from '@/components/ui/image'
+import { Video } from '@/components/ui/video'
 
 Der Zeitplan-Block löst Workflows automatisch nach einem wiederkehrenden Zeitplan zu bestimmten Intervallen oder Zeiten aus.
 
@@ -20,47 +21,54 @@ Der Zeitplan-Block löst Workflows automatisch nach einem wiederkehrenden Zeitpl
 
 ## Zeitplan-Optionen
 
-Konfigurieren Sie, wann Ihr Workflow ausgeführt wird:
+Konfigurieren Sie, wann Ihr Workflow ausgeführt wird, mit den Dropdown-Optionen:
 
 <Tabs items={['Einfache Intervalle', 'Cron-Ausdrücke']}>
   <Tab>
     <ul className="list-disc space-y-1 pl-6">
-      <li><strong>Alle X Minuten</strong>: Ausführung in Minutenintervallen (1-1440)</li>
-      <li><strong>Stündlich</strong>: Ausführung zu einer bestimmten Minute jeder Stunde</li>
-      <li><strong>Täglich</strong>: Ausführung zu einer bestimmten Uhrzeit jeden Tag</li>
-      <li><strong>Wöchentlich</strong>: Ausführung an einem bestimmten Tag und einer bestimmten Uhrzeit jede Woche</li>
-      <li><strong>Monatlich</strong>: Ausführung an einem bestimmten Tag und einer bestimmten Uhrzeit jeden Monat</li>
+      <li><strong>Alle paar Minuten</strong>: 5, 15, 30 Minuten-Intervalle</li>
+      <li><strong>Stündlich</strong>: Jede Stunde oder alle paar Stunden</li>
+      <li><strong>Täglich</strong>: Einmal oder mehrmals pro Tag</li>
+      <li><strong>Wöchentlich</strong>: Bestimmte Wochentage</li>
+      <li><strong>Monatlich</strong>: Bestimmte Tage des Monats</li>
     </ul>
   </Tab>
   <Tab>
-    <p>Verwenden Sie Cron-Ausdrücke für erweiterte Planung:</p>
+    <p>Verwenden Sie Cron-Ausdrücke für erweiterte Zeitplanung:</p>
     <div className="text-sm space-y-1">
       <div><code>0 9 * * 1-5</code> - Jeden Wochentag um 9 Uhr</div>
       <div><code>*/15 * * * *</code> - Alle 15 Minuten</div>
-      <div><code>0 0 1 * *</code> - Erster Tag jedes Monats</div>
+      <div><code>0 0 1 * *</code> - Am ersten Tag jedes Monats</div>
     </div>
   </Tab>
 </Tabs>
 
-## Aktivierung
+## Zeitpläne konfigurieren
 
-Zeitpläne sind an die Workflow-Bereitstellung gebunden:
+Wenn ein Workflow geplant ist:
+- Der Zeitplan wird **aktiv** und zeigt die nächste Ausführungszeit an
+- Klicken Sie auf die Schaltfläche **"Geplant"**, um den Zeitplan zu deaktivieren
+- Zeitpläne werden nach **3 aufeinanderfolgenden Fehlern** automatisch deaktiviert
 
-- **Workflow bereitstellen** → Zeitplan wird aktiv und beginnt mit der Ausführung
-- **Workflow-Bereitstellung aufheben** → Zeitplan wird entfernt
-- **Workflow erneut bereitstellen** → Zeitplan wird mit aktueller Konfiguration neu erstellt
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/schedule-2.png"
+    alt="Aktiver Zeitplan-Block"
+    width={500}
+    height={400}
+    className="my-6"
+  />
+</div>
 
-<Callout>
-Sie müssen Ihren Workflow bereitstellen, damit der Zeitplan mit der Ausführung beginnt. Konfigurieren Sie den Zeitplan-Block und stellen Sie ihn dann über die Symbolleiste bereit.
-</Callout>
-
-## Automatische Deaktivierung
-
-Zeitpläne werden nach **100 aufeinanderfolgenden Fehlern** automatisch deaktiviert, um unkontrollierte Fehler zu verhindern. Bei Deaktivierung:
-
-- Erscheint ein Warnhinweis auf dem Zeitplan-Block
-- Die Ausführung des Zeitplans wird gestoppt
-- Klicken Sie auf den Hinweis, um den Zeitplan zu reaktivieren
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/schedule-3.png"
+    alt="Deaktivierter Zeitplan"
+    width={500}
+    height={350}
+    className="my-6"
+  />
+</div>
 
 <div className="flex justify-center">
   <Image
@@ -72,6 +80,8 @@ Zeitpläne werden nach **100 aufeinanderfolgenden Fehlern** automatisch deaktivi
   />
 </div>
 
+Deaktivierte Zeitpläne zeigen an, wann sie zuletzt aktiv waren. Klicken Sie auf das **"Deaktiviert"**-Badge, um den Zeitplan wieder zu aktivieren.
+
 <Callout>
-Zeitplan-Blöcke können keine eingehenden Verbindungen empfangen und dienen ausschließlich als Workflow-Einstiegspunkte.
+Zeitplan-Blöcke können keine eingehenden Verbindungen empfangen und dienen ausschließlich als Workflow-Auslöser.
 </Callout>

apps/docs/content/docs/de/triggers/webhook.mdx

@@ -15,7 +15,7 @@ Der generische Webhook-Block erstellt einen flexiblen Endpunkt, der beliebige Pa
 
 <div className="flex justify-center">
   <Image
-    src="/static/blocks/webhook-trigger.png"
+    src="/static/blocks/webhook.png"
     alt="Generische Webhook-Konfiguration"
     width={500}
     height={400}

apps/docs/content/docs/en/blocks/meta.json

@@ -14,7 +14,6 @@
     "router",
     "variables",
     "wait",
-    "webhook",
     "workflow"
   ]
 }

apps/docs/content/docs/en/blocks/router.mdx

@@ -2,15 +2,16 @@
 title: Router
 ---
 
+import { Callout } from 'fumadocs-ui/components/callout'
 import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
 import { Image } from '@/components/ui/image'
 
-The Router block uses AI to intelligently route workflows based on content analysis. Unlike Condition blocks that use simple rules, Routers understand context and intent. Each route you define creates a separate output port, allowing you to connect different paths to different downstream blocks.
+The Router block uses AI to intelligently route workflows based on content analysis. Unlike Condition blocks that use simple rules, Routers understand context and intent.
 
 <div className="flex justify-center">
   <Image
     src="/static/blocks/router.png"
-    alt="Router Block with Multiple Route Ports"
+    alt="Router Block with Multiple Paths"
     width={500}
     height={400}
     className="my-6"
@@ -31,23 +32,21 @@ The Router block uses AI to intelligently route workflows based on content analy
 
 ## Configuration Options
 
-### Context
+### Content/Prompt
 
-The context that the Router will analyze to make routing decisions. This is the input data that gets evaluated against your route descriptions. It can be:
+The content or prompt that the Router will analyze to make routing decisions. This can be:
 
 - A direct user query or input
 - Output from a previous block
 - A system-generated message
-- Any text content that needs intelligent routing
 
-### Routes
+### Target Blocks
 
-Define the possible paths that the Router can take. Each route consists of:
+The possible destination blocks that the Router can select from. The Router will automatically detect connected blocks, but you can also:
 
-- **Route Title**: A name for the route (e.g., "Sales", "Support", "Technical")
-- **Route Description**: A clear description of when this route should be selected (e.g., "Route here when the query is about pricing, purchasing, or sales inquiries")
-
-Each route you add creates a **separate output port** on the Router block. Connect each port to the appropriate downstream block for that route.
+- Customize the descriptions of target blocks to improve routing accuracy
+- Specify routing criteria for each target block
+- Exclude certain blocks from being considered as routing targets
 
 ### Model Selection
 
@@ -67,9 +66,8 @@ Your API key for the selected LLM provider. This is securely stored and used for
 
 ## Outputs
 
-- **`<router.context>`**: The context that was analyzed
-- **`<router.selectedRoute>`**: The ID of the selected route
-- **`<router.selected_path>`**: Details of the chosen destination block
+- **`<router.prompt>`**: Summary of the routing prompt
+- **`<router.selected_path>`**: Chosen destination block
 - **`<router.tokens>`**: Token usage statistics
 - **`<router.cost>`**: Estimated routing cost
 - **`<router.model>`**: Model used for decision-making
@@ -77,43 +75,26 @@ Your API key for the selected LLM provider. This is securely stored and used for
 ## Example Use Cases
 
 **Customer Support Triage** - Route tickets to specialized departments
-
 ```
-Input (Ticket) → Router
-                  ├── [Sales Route] → Agent (Sales Team)
-                  ├── [Technical Route] → Agent (Engineering)
-                  └── [Billing Route] → Agent (Finance)
+Input (Ticket) → Router → Agent (Engineering) or Agent (Finance)
 ```
 
 **Content Classification** - Classify and route user-generated content
-
 ```
-Input (Feedback) → Router
-                    ├── [Product Feedback] → Workflow (Product Team)
-                    └── [Bug Report] → Workflow (Technical Team)
+Input (Feedback) → Router → Workflow (Product) or Workflow (Technical)
 ```
 
 **Lead Qualification** - Route leads based on qualification criteria
-
 ```
-Input (Lead) → Router
-                ├── [Enterprise] → Agent (Enterprise Sales)
-                └── [Self-serve] → Workflow (Automated Onboarding)
+Input (Lead) → Router → Agent (Enterprise Sales) or Workflow (Self-serve)
 ```
 
-## Error Handling
-
-When the Router cannot determine an appropriate route for the given context, it will route to the **error path** instead of arbitrarily selecting a route. This happens when:
-
-- The context doesn't clearly match any of the defined route descriptions
-- The AI determines that none of the available routes are appropriate
 
 ## Best Practices
 
-- **Write clear route descriptions**: Each route description should clearly explain when that route should be selected. Be specific about the criteria.
-- **Make routes mutually exclusive**: When possible, ensure route descriptions don't overlap to prevent ambiguous routing decisions.
-- **Connect an error path**: Handle cases where no route matches by connecting an error handler for graceful fallback behavior.
-- **Use descriptive route titles**: Route titles appear in the workflow canvas, so make them meaningful for readability.
-- **Test with diverse inputs**: Ensure the Router handles various input types, edge cases, and unexpected content.
-- **Monitor routing performance**: Review routing decisions regularly and refine route descriptions based on actual usage patterns.
-- **Choose appropriate models**: Use models with strong reasoning capabilities for complex routing decisions.
+- **Provide clear target descriptions**: Help the Router understand when to select each destination with specific, detailed descriptions
+- **Use specific routing criteria**: Define clear conditions and examples for each path to improve accuracy
+- **Implement fallback paths**: Connect a default destination for when no specific path is appropriate
+- **Test with diverse inputs**: Ensure the Router handles various input types, edge cases, and unexpected content
+- **Monitor routing performance**: Review routing decisions regularly and refine criteria based on actual usage patterns
+- **Choose appropriate models**: Use models with strong reasoning capabilities for complex routing decisions

apps/docs/content/docs/en/blocks/webhook.mdx

@@ -1,87 +0,0 @@
----
-title: Webhook
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-import { Image } from '@/components/ui/image'
-
-The Webhook block sends HTTP POST requests to external webhook endpoints with automatic webhook headers and optional HMAC signing.
-
-<div className="flex justify-center">
-  <Image
-    src="/static/blocks/webhook.png"
-    alt="Webhook Block"
-    width={500}
-    height={400}
-    className="my-6"
-  />
-</div>
-
-## Configuration
-
-### Webhook URL
-
-The destination endpoint for your webhook request. Supports both static URLs and dynamic values from other blocks.
-
-### Payload
-
-JSON data to send in the request body. Use the AI wand to generate payloads or reference workflow variables:
-
-```json
-{
-  "event": "workflow.completed",
-  "data": {
-    "result": "<agent.content>",
-    "timestamp": "<function.result>"
-  }
-}
-```
-
-### Signing Secret
-
-Optional secret for HMAC-SHA256 payload signing. When provided, adds an `X-Webhook-Signature` header:
-
-```
-X-Webhook-Signature: t=1704067200000,v1=5d41402abc4b2a76b9719d911017c592...
-```
-
-To verify signatures, compute `HMAC-SHA256(secret, "${timestamp}.${body}")` and compare with the `v1` value.
-
-### Additional Headers
-
-Custom key-value headers to include with the request. These override any automatic headers with the same name.
-
-## Automatic Headers
-
-Every request includes these headers automatically:
-
-| Header | Description |
-|--------|-------------|
-| `Content-Type` | `application/json` |
-| `X-Webhook-Timestamp` | Unix timestamp in milliseconds |
-| `X-Delivery-ID` | Unique UUID for this delivery |
-| `Idempotency-Key` | Same as `X-Delivery-ID` for deduplication |
-
-## Outputs
-
-| Output | Type | Description |
-|--------|------|-------------|
-| `data` | json | Response body from the endpoint |
-| `status` | number | HTTP status code |
-| `headers` | object | Response headers |
-
-## Example Use Cases
-
-**Notify external services** - Send workflow results to Slack, Discord, or custom endpoints
-```
-Agent → Function (format) → Webhook (notify)
-```
-
-**Trigger external workflows** - Start processes in other systems when conditions are met
-```
-Condition (check) → Webhook (trigger) → Response
-```
-
-<Callout>
-The Webhook block always uses POST. For other HTTP methods or more control, use the [API block](/blocks/api).
-</Callout>

apps/docs/content/docs/en/enterprise/index.mdx

@@ -1,110 +0,0 @@
----
-title: Enterprise
-description: Enterprise features for business organizations
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-
-Sim Studio Enterprise provides advanced features for organizations with enhanced security, compliance, and management requirements.
-
----
-
-## Access Control
-
-Define permission groups to control what features and integrations team members can use.
-
-### Features
-
-- **Allowed Model Providers** - Restrict which AI providers users can access (OpenAI, Anthropic, Google, etc.)
-- **Allowed Blocks** - Control which workflow blocks are available
-- **Platform Settings** - Hide Knowledge Base, disable MCP tools, disable custom tools, or disable invitations
-
-### Setup
-
-1. Navigate to **Settings** → **Access Control** in your workspace
-2. Create a permission group with your desired restrictions
-3. Add team members to the permission group
-
-<Callout type="info">
-  Users not assigned to any permission group have full access. Permission restrictions are enforced at both UI and execution time.
-</Callout>
-
----
-
-## Single Sign-On (SSO)
-
-Enterprise authentication with SAML 2.0 and OIDC support for centralized identity management.
-
-### Supported Providers
-
-- Okta
-- Azure AD / Entra ID
-- Google Workspace
-- OneLogin
-- Any SAML 2.0 or OIDC provider
-
-### Setup
-
-1. Navigate to **Settings** → **SSO** in your workspace
-2. Choose your identity provider
-3. Configure the connection using your IdP's metadata
-4. Enable SSO for your organization
-
-<Callout type="info">
-  Once SSO is enabled, team members authenticate through your identity provider instead of email/password.
-</Callout>
-
----
-
-## Self-Hosted Configuration
-
-For self-hosted deployments, enterprise features can be enabled via environment variables without requiring billing.
-
-### Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `ORGANIZATIONS_ENABLED`, `NEXT_PUBLIC_ORGANIZATIONS_ENABLED` | Enable team/organization management |
-| `ACCESS_CONTROL_ENABLED`, `NEXT_PUBLIC_ACCESS_CONTROL_ENABLED` | Permission groups for access restrictions |
-| `SSO_ENABLED`, `NEXT_PUBLIC_SSO_ENABLED` | Single Sign-On with SAML/OIDC |
-| `CREDENTIAL_SETS_ENABLED`, `NEXT_PUBLIC_CREDENTIAL_SETS_ENABLED` | Polling Groups for email triggers |
-| `DISABLE_INVITATIONS`, `NEXT_PUBLIC_DISABLE_INVITATIONS` | Globally disable workspace/organization invitations |
-
-### Organization Management
-
-When billing is disabled, use the Admin API to manage organizations:
-
-```bash
-# Create an organization
-curl -X POST https://your-instance/api/v1/admin/organizations \
-  -H "x-admin-key: YOUR_ADMIN_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"name": "My Organization", "ownerId": "user-id-here"}'
-
-# Add a member
-curl -X POST https://your-instance/api/v1/admin/organizations/{orgId}/members \
-  -H "x-admin-key: YOUR_ADMIN_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"userId": "user-id-here", "role": "admin"}'
-```
-
-### Workspace Members
-
-When invitations are disabled, use the Admin API to manage workspace memberships directly:
-
-```bash
-# Add a user to a workspace
-curl -X POST https://your-instance/api/v1/admin/workspaces/{workspaceId}/members \
-  -H "x-admin-key: YOUR_ADMIN_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"userId": "user-id-here", "permissions": "write"}'
-
-# Remove a user from a workspace
-curl -X DELETE "https://your-instance/api/v1/admin/workspaces/{workspaceId}/members?userId=user-id-here" \
-  -H "x-admin-key: YOUR_ADMIN_API_KEY"
-```
-
-### Notes
-
-- Enabling `ACCESS_CONTROL_ENABLED` automatically enables organizations, as access control requires organization membership.
-- When `DISABLE_INVITATIONS` is set, users cannot send invitations. Use the Admin API to manage workspace and organization memberships instead.

apps/docs/content/docs/en/execution/costs.mdx

@@ -48,40 +48,40 @@ The model breakdown shows:
 
 <Tabs items={['Hosted Models', 'Bring Your Own API Key']}>
   <Tab>
-    **Hosted Models** - Sim provides API keys with a 1.4x pricing multiplier for Agent blocks:
+    **Hosted Models** - Sim provides API keys with a 2.5x pricing multiplier:
 
     **OpenAI**
     | Model | Base Price (Input/Output) | Hosted Price (Input/Output) |
     |-------|---------------------------|----------------------------|
-    | GPT-5.1 | $1.25 / $10.00 | $1.75 / $14.00 |
-    | GPT-5 | $1.25 / $10.00 | $1.75 / $14.00 |
-    | GPT-5 Mini | $0.25 / $2.00 | $0.35 / $2.80 |
-    | GPT-5 Nano | $0.05 / $0.40 | $0.07 / $0.56 |
-    | GPT-4o | $2.50 / $10.00 | $3.50 / $14.00 |
-    | GPT-4.1 | $2.00 / $8.00 | $2.80 / $11.20 |
-    | GPT-4.1 Mini | $0.40 / $1.60 | $0.56 / $2.24 |
-    | GPT-4.1 Nano | $0.10 / $0.40 | $0.14 / $0.56 |
-    | o1 | $15.00 / $60.00 | $21.00 / $84.00 |
-    | o3 | $2.00 / $8.00 | $2.80 / $11.20 |
-    | o4 Mini | $1.10 / $4.40 | $1.54 / $6.16 |
+    | GPT-5.1 | $1.25 / $10.00 | $3.13 / $25.00 |
+    | GPT-5 | $1.25 / $10.00 | $3.13 / $25.00 |
+    | GPT-5 Mini | $0.25 / $2.00 | $0.63 / $5.00 |
+    | GPT-5 Nano | $0.05 / $0.40 | $0.13 / $1.00 |
+    | GPT-4o | $2.50 / $10.00 | $6.25 / $25.00 |
+    | GPT-4.1 | $2.00 / $8.00 | $5.00 / $20.00 |
+    | GPT-4.1 Mini | $0.40 / $1.60 | $1.00 / $4.00 |
+    | GPT-4.1 Nano | $0.10 / $0.40 | $0.25 / $1.00 |
+    | o1 | $15.00 / $60.00 | $37.50 / $150.00 |
+    | o3 | $2.00 / $8.00 | $5.00 / $20.00 |
+    | o4 Mini | $1.10 / $4.40 | $2.75 / $11.00 |
 
     **Anthropic**
     | Model | Base Price (Input/Output) | Hosted Price (Input/Output) |
     |-------|---------------------------|----------------------------|
-    | Claude Opus 4.5 | $5.00 / $25.00 | $7.00 / $35.00 |
-    | Claude Opus 4.1 | $15.00 / $75.00 | $21.00 / $105.00 |
-    | Claude Sonnet 4.5 | $3.00 / $15.00 | $4.20 / $21.00 |
-    | Claude Sonnet 4.0 | $3.00 / $15.00 | $4.20 / $21.00 |
-    | Claude Haiku 4.5 | $1.00 / $5.00 | $1.40 / $7.00 |
+    | Claude Opus 4.5 | $5.00 / $25.00 | $12.50 / $62.50 |
+    | Claude Opus 4.1 | $15.00 / $75.00 | $37.50 / $187.50 |
+    | Claude Sonnet 4.5 | $3.00 / $15.00 | $7.50 / $37.50 |
+    | Claude Sonnet 4.0 | $3.00 / $15.00 | $7.50 / $37.50 |
+    | Claude Haiku 4.5 | $1.00 / $5.00 | $2.50 / $12.50 |
 
     **Google**
     | Model | Base Price (Input/Output) | Hosted Price (Input/Output) |
     |-------|---------------------------|----------------------------|
-    | Gemini 3 Pro Preview | $2.00 / $12.00 | $2.80 / $16.80 |
-    | Gemini 2.5 Pro | $1.25 / $10.00 | $1.75 / $14.00 |
-    | Gemini 2.5 Flash | $0.30 / $2.50 | $0.42 / $3.50 |
+    | Gemini 3 Pro Preview | $2.00 / $12.00 | $5.00 / $30.00 |
+    | Gemini 2.5 Pro | $0.15 / $0.60 | $0.38 / $1.50 |
+    | Gemini 2.5 Flash | $0.15 / $0.60 | $0.38 / $1.50 |
 
-    *The 1.4x multiplier covers infrastructure and API management costs.*
+    *The 2.5x multiplier covers infrastructure and API management costs.*
   </Tab>
 
   <Tab>
@@ -104,31 +104,6 @@ The model breakdown shows:
   Pricing shown reflects rates as of September 10, 2025. Check provider documentation for current pricing.
 </Callout>
 
-## Bring Your Own Key (BYOK)
-
-Use your own API keys for AI model providers instead of Sim Studio's hosted keys to pay base prices with no markup.
-
-### Supported Providers
-
-| Provider | Usage |
-|----------|-------|
-| OpenAI | Knowledge Base embeddings, Agent block |
-| Anthropic | Agent block |
-| Google | Agent block |
-| Mistral | Knowledge Base OCR |
-
-### Setup
-
-1. Navigate to **Settings** → **BYOK** in your workspace
-2. Click **Add Key** for your provider
-3. Enter your API key and save
-
-<Callout type="info">
-  BYOK keys are encrypted at rest. Only workspace admins can manage keys.
-</Callout>
-
-When configured, workflows use your key instead of Sim Studio's hosted keys. If removed, workflows automatically fall back to hosted keys with the multiplier.
-
 ## Cost Optimization Strategies
 
 - **Model Selection**: Choose models based on task complexity. Simple tasks can use GPT-4.1-nano while complex reasoning might need o1 or Claude Opus.
@@ -208,7 +183,7 @@ Different subscription plans have different usage limits:
 
 | Plan | Monthly Usage Limit | Rate Limits (per minute) |
 |------|-------------------|-------------------------|
-| **Free** | $20 | 5 sync, 10 async |
+| **Free** | $10 | 5 sync, 10 async |
 | **Pro** | $100 | 10 sync, 50 async |
 | **Team** | $500 (pooled) | 50 sync, 100 async |
 | **Enterprise** | Custom | Custom |

apps/docs/content/docs/en/execution/form.mdx

@@ -1,136 +0,0 @@
----
-title: Form Deployment
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
-
-Deploy your workflow as an embeddable form that users can fill out on your website or share via link. Form submissions trigger your workflow with the `form` trigger type.
-
-## Overview
-
-Form deployment turns your workflow's Input Format into a responsive form that can be:
-- Shared via a direct link (e.g., `https://sim.ai/form/my-survey`)
-- Embedded in any website using an iframe
-
-When a user submits the form, it triggers your workflow with the form data.
-
-<Callout type="info">
-Forms derive their fields from your workflow's Start block Input Format. Each field becomes a form input with the appropriate type.
-</Callout>
-
-## Creating a Form
-
-1. Open your workflow and click **Deploy**
-2. Select the **Form** tab
-3. Configure:
-   - **URL**: Unique identifier (e.g., `contact-form` → `sim.ai/form/contact-form`)
-   - **Title**: Form heading
-   - **Description**: Optional subtitle
-   - **Form Fields**: Customize labels and descriptions for each field
-   - **Authentication**: Public, password-protected, or email whitelist
-   - **Thank You Message**: Shown after submission
-4. Click **Launch**
-
-## Field Type Mapping
-
-| Input Format Type | Form Field |
-|------------------|------------|
-| `string` | Text input |
-| `number` | Number input |
-| `boolean` | Toggle switch |
-| `object` | JSON editor |
-| `array` | JSON array editor |
-| `files` | File upload |
-
-## Access Control
-
-| Mode | Description |
-|------|-------------|
-| **Public** | Anyone with the link can submit |
-| **Password** | Users must enter a password |
-| **Email Whitelist** | Only specified emails/domains can submit |
-
-For email whitelist:
-- Exact: `user@example.com`
-- Domain: `@example.com` (all emails from domain)
-
-## Embedding
-
-### Direct Link
-
-```
-https://sim.ai/form/your-identifier
-```
-
-### Iframe
-
-```html
-<iframe
-  src="https://sim.ai/form/your-identifier"
-  width="100%"
-  height="600"
-  frameborder="0"
-  title="Form"
-></iframe>
-```
-
-## API Submission
-
-Submit forms programmatically:
-
-<Tabs items={['cURL', 'TypeScript']}>
-  <Tab value="cURL">
-```bash
-curl -X POST https://sim.ai/api/form/your-identifier \
-  -H "Content-Type: application/json" \
-  -d '{
-    "formData": {
-      "name": "John Doe",
-      "email": "john@example.com"
-    }
-  }'
-```
-  </Tab>
-  <Tab value="TypeScript">
-```typescript
-const response = await fetch('https://sim.ai/api/form/your-identifier', {
-  method: 'POST',
-  headers: { 'Content-Type': 'application/json' },
-  body: JSON.stringify({
-    formData: {
-      name: 'John Doe',
-      email: 'john@example.com'
-    }
-  })
-});
-
-const result = await response.json();
-// { success: true, data: { executionId: '...' } }
-```
-  </Tab>
-</Tabs>
-
-### Protected Forms
-
-For password-protected forms:
-```bash
-curl -X POST https://sim.ai/api/form/your-identifier \
-  -H "Content-Type: application/json" \
-  -d '{ "password": "secret", "formData": { "name": "John" } }'
-```
-
-For email-protected forms:
-```bash
-curl -X POST https://sim.ai/api/form/your-identifier \
-  -H "Content-Type: application/json" \
-  -d '{ "email": "allowed@example.com", "formData": { "name": "John" } }'
-```
-
-## Troubleshooting
-
-**"No input fields configured"** - Add Input Format fields to your Start block.
-
-**Form not loading in iframe** - Check your site's CSP allows iframes from `sim.ai`.
-
-**Submissions failing** - Verify the identifier is correct and required fields are filled.

apps/docs/content/docs/en/execution/meta.json

@@ -1,3 +1,3 @@
 {
-  "pages": ["index", "basics", "api", "form", "logging", "costs"]
+  "pages": ["index", "basics", "api", "logging", "costs"]
 }

apps/docs/content/docs/en/keyboard-shortcuts/index.mdx

@@ -1,64 +0,0 @@
----
-title: Keyboard Shortcuts
-description: Master the workflow canvas with keyboard shortcuts and mouse controls
----
-
-import { Callout } from 'fumadocs-ui/components/callout'
-
-Speed up your workflow building with these keyboard shortcuts and mouse controls. All shortcuts work when the canvas is focused (not when typing in an input field).
-
-<Callout type="info">
-  **Mod** refers to `Cmd` on macOS and `Ctrl` on Windows/Linux.
-</Callout>
-
-## Canvas Controls
-
-### Mouse Controls
-
-| Action | Control |
-|--------|---------|
-| Pan/move canvas | Left-drag on empty space |
-| Pan/move canvas | Scroll or trackpad |
-| Select multiple blocks | Right-drag to draw selection box |
-| Drag block | Left-drag on block header |
-| Add to selection | `Mod` + click on blocks |
-
-### Workflow Actions
-
-| Shortcut | Action |
-|----------|--------|
-| `Mod` + `Enter` | Run workflow (or cancel if running) |
-| `Mod` + `Z` | Undo |
-| `Mod` + `Shift` + `Z` | Redo |
-| `Mod` + `C` | Copy selected blocks |
-| `Mod` + `V` | Paste blocks |
-| `Delete` or `Backspace` | Delete selected blocks or edges |
-| `Shift` + `L` | Auto-layout canvas |
-
-## Panel Navigation
-
-These shortcuts switch between panel tabs on the right side of the canvas.
-
-| Shortcut | Action |
-|----------|--------|
-| `C` | Focus Copilot tab |
-| `T` | Focus Toolbar tab |
-| `E` | Focus Editor tab |
-| `Mod` + `F` | Focus Toolbar search |
-
-## Global Navigation
-
-| Shortcut | Action |
-|----------|--------|
-| `Mod` + `K` | Open search |
-| `Mod` + `Shift` + `A` | Add new agent workflow |
-| `Mod` + `Y` | Go to templates |
-| `Mod` + `L` | Go to logs |
-
-## Utility
-
-| Shortcut | Action |
-|----------|--------|
-| `Mod` + `D` | Clear terminal console |
-| `Mod` + `E` | Clear notifications |
-

apps/docs/content/docs/en/knowledgebase/index.mdx

@@ -34,15 +34,9 @@ Once your documents are processed, you can view and edit the individual chunks.
 <Image src="/static/knowledgebase/knowledgebase.png" alt="Document chunks view showing processed content" width={800} height={500} />
 
 ### Chunk Configuration
-
-When creating a knowledge base, you can configure how documents are split into chunks:
-
-| Setting | Unit | Default | Range | Description |
-|---------|------|---------|-------|-------------|
-| **Max Chunk Size** | tokens | 1,024 | 100-4,000 | Maximum size of each chunk (1 token ≈ 4 characters) |
-| **Min Chunk Size** | characters | 1 | 1-2,000 | Minimum chunk size to avoid tiny fragments |
-| **Overlap** | characters | 200 | 0-500 | Context overlap between consecutive chunks |
-
+- **Default chunk size**: 1,024 characters
+- **Configurable range**: 100-4,000 characters per chunk
+- **Smart overlap**: 200 characters by default for context preservation
 - **Hierarchical splitting**: Respects document structure (sections, paragraphs, sentences)
 
 ### Editing Capabilities

apps/docs/content/docs/en/mcp/deploy-workflows.mdx

@@ -1,108 +0,0 @@
----
-title: Deploy Workflows as MCP
-description: Expose your workflows as MCP tools for external AI assistants and applications
----
-
-import { Video } from '@/components/ui/video'
-import { Callout } from 'fumadocs-ui/components/callout'
-
-Deploy your workflows as MCP tools to make them accessible to external AI assistants like Claude Desktop, Cursor, and other MCP-compatible clients. This turns your workflows into callable tools that can be invoked from anywhere.
-
-## Creating and Managing MCP Servers
-
-MCP servers group your workflow tools together. Create and manage them in workspace settings:
-
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp/mcp-server.mp4" width={700} height={450} />
-</div>
-
-1. Navigate to **Settings → Deployed MCPs**
-2. Click **Create Server**
-3. Enter a name and optional description
-4. Copy the server URL for use in your MCP clients
-5. View and manage all tools added to the server
-
-## Adding a Workflow as a Tool
-
-Once your workflow is deployed, you can expose it as an MCP tool:
-
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp/mcp-deploy-tool.mp4" width={700} height={450} />
-</div>
-
-1. Open your deployed workflow
-2. Click **Deploy** and go to the **MCP** tab
-3. Configure the tool name and description
-4. Add descriptions for each parameter (helps AI understand inputs)
-5. Select which MCP servers to add it to
-
-<Callout type="info">
-The workflow must be deployed before it can be added as an MCP tool.
-</Callout>
-
-## Tool Configuration
-
-### Tool Name
-Use lowercase letters, numbers, and underscores. The name should be descriptive and follow MCP naming conventions (e.g., `search_documents`, `send_email`).
-
-### Description
-Write a clear description of what the tool does. This helps AI assistants understand when to use the tool.
-
-### Parameters
-Your workflow's input format fields become tool parameters. Add descriptions to each parameter to help AI assistants provide correct values.
-
-## Connecting MCP Clients
-
-Use the server URL from settings to connect external applications:
-
-### Claude Desktop
-Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
-
-```json
-{
-  "mcpServers": {
-    "my-sim-workflows": {
-      "command": "npx",
-      "args": ["-y", "mcp-remote", "YOUR_SERVER_URL"]
-    }
-  }
-}
-```
-
-### Cursor
-Add the server URL in Cursor's MCP settings using the same mcp-remote pattern.
-
-<Callout type="warn">
-Include your API key header (`X-API-Key`) for authenticated access when using mcp-remote or other HTTP-based MCP transports.
-</Callout>
-
-## Server Management
-
-From the server detail view in **Settings → Deployed MCPs**, you can:
-
-- **View tools**: See all workflows added to a server
-- **Copy URL**: Get the server URL for MCP clients
-- **Add workflows**: Add more deployed workflows as tools
-- **Remove tools**: Remove workflows from the server
-- **Delete server**: Remove the entire server and all its tools
-
-## How It Works
-
-When an MCP client calls your tool:
-
-1. The request is received at your MCP server URL
-2. Sim validates the request and maps parameters to workflow inputs
-3. The deployed workflow executes with the provided inputs
-4. Results are returned to the MCP client
-
-Workflows execute using the same deployment version as API calls, ensuring consistent behavior.
-
-## Permission Requirements
-
-| Action | Required Permission |
-|--------|-------------------|
-| Create MCP servers | **Admin** |
-| Add workflows to servers | **Write** or **Admin** |
-| View MCP servers | **Read**, **Write**, or **Admin** |
-| Delete MCP servers | **Admin** |
-

apps/docs/content/docs/en/mcp/index.mdx

@@ -1,10 +1,8 @@
 ---
-title: Using MCP Tools
-description: Connect external tools and services using the Model Context Protocol
+title: MCP (Model Context Protocol)
 ---
 
 import { Image } from '@/components/ui/image'
-import { Video } from '@/components/ui/video'
 import { Callout } from 'fumadocs-ui/components/callout'
 
 The Model Context Protocol ([MCP](https://modelcontextprotocol.com/)) allows you to connect external tools and services using a standardized protocol, enabling you to integrate APIs and services directly into your workflows. With MCP, you can extend Sim's capabilities by adding custom integrations that work seamlessly with your agents and workflows.
@@ -22,12 +20,18 @@ MCP is an open standard that enables AI assistants to securely connect to extern
 
 MCP servers provide collections of tools that your agents can use. Configure them in workspace settings:
 
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="mcp/settings-mcp-tools.mp4" width={700} height={450} />
+<div className="flex justify-center">
+  <Image
+    src="/static/blocks/mcp-1.png"
+    alt="Configuring MCP Server in Settings"
+    width={700}
+    height={450}
+    className="my-6"
+  />
 </div>
 
 1. Navigate to your workspace settings
-2. Go to the **Deployed MCPs** section
+2. Go to the **MCP Servers** section
 3. Click **Add MCP Server**
 4. Enter the server configuration details
 5. Save the configuration
@@ -36,10 +40,6 @@ MCP servers provide collections of tools that your agents can use. Configure the
 You can also configure MCP servers directly from the toolbar in an Agent block for quick setup.
 </Callout>
 
-### Refresh Tools
-
-Click **Refresh** on a server to fetch the latest tool schemas and automatically update any agent blocks using those tools with the new parameter definitions.
-
 ## Using MCP Tools in Agents
 
 Once MCP servers are configured, their tools become available within your agent blocks:

apps/docs/content/docs/en/mcp/meta.json

@@ -1,5 +0,0 @@
-{
-  "title": "MCP",
-  "pages": ["index", "deploy-workflows"],
-  "defaultOpen": false
-}

apps/docs/content/docs/en/meta.json

@@ -14,9 +14,7 @@
     "execution",
     "permissions",
     "sdks",
-    "self-hosting",
-    "./enterprise/index",
-    "./keyboard-shortcuts/index"
+    "self-hosting"
   ],
   "defaultOpen": false
 }

apps/docs/content/docs/en/tools/ahrefs.mdx

@@ -198,3 +198,8 @@ Get a list of broken backlinks pointing to a target domain or URL. Useful for id
 | `brokenBacklinks` | array | List of broken backlinks |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `ahrefs`

apps/docs/content/docs/en/tools/airtable.mdx

@@ -128,3 +128,8 @@ Update multiple existing records in an Airtable table
 | `records` | json | Array of updated Airtable records |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `airtable`

apps/docs/content/docs/en/tools/apify.mdx

@@ -86,3 +86,8 @@ Run an APIFY actor asynchronously with polling for long-running tasks
 | `items` | array | Dataset items \(if completed\) |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `apify`

apps/docs/content/docs/en/tools/apollo.mdx

@@ -61,9 +61,7 @@ Search Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `people` | json | Array of people matching the search criteria |
-| `page` | number | Current page number |
-| `per_page` | number | Results per page |
-| `total_entries` | number | Total matching entries |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_people_enrich`
 
@@ -88,7 +86,7 @@ Enrich data for a single person using Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `person` | json | Enriched person data from Apollo |
-| `enriched` | boolean | Whether the person was successfully enriched |
+| `metadata` | json | Enrichment metadata including enriched status |
 
 ### `apollo_people_bulk_enrich`
 
@@ -108,8 +106,7 @@ Enrich data for up to 10 people at once using Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `people` | json | Array of enriched people data |
-| `total` | number | Total number of people processed |
-| `enriched` | number | Number of people successfully enriched |
+| `metadata` | json | Bulk enrichment metadata including total and enriched counts |
 
 ### `apollo_organization_search`
 
@@ -132,9 +129,7 @@ Search Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `organizations` | json | Array of organizations matching the search criteria |
-| `page` | number | Current page number |
-| `per_page` | number | Results per page |
-| `total_entries` | number | Total matching entries |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_organization_enrich`
 
@@ -153,7 +148,7 @@ Enrich data for a single organization using Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `organization` | json | Enriched organization data from Apollo |
-| `enriched` | boolean | Whether the organization was successfully enriched |
+| `metadata` | json | Enrichment metadata including enriched status |
 
 ### `apollo_organization_bulk_enrich`
 
@@ -171,8 +166,7 @@ Enrich data for up to 10 organizations at once using Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `organizations` | json | Array of enriched organization data |
-| `total` | number | Total number of organizations processed |
-| `enriched` | number | Number of organizations successfully enriched |
+| `metadata` | json | Bulk enrichment metadata including total and enriched counts |
 
 ### `apollo_contact_create`
 
@@ -195,7 +189,7 @@ Create a new contact in your Apollo database
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `contact` | json | Created contact data from Apollo |
-| `created` | boolean | Whether the contact was successfully created |
+| `metadata` | json | Creation metadata including created status |
 
 ### `apollo_contact_update`
 
@@ -219,7 +213,7 @@ Update an existing contact in your Apollo database
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `contact` | json | Updated contact data from Apollo |
-| `updated` | boolean | Whether the contact was successfully updated |
+| `metadata` | json | Update metadata including updated status |
 
 ### `apollo_contact_search`
 
@@ -240,7 +234,7 @@ Search your team
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `contacts` | json | Array of contacts matching the search criteria |
-| `pagination` | json | Pagination information |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_contact_bulk_create`
 
@@ -260,9 +254,7 @@ Create up to 100 contacts at once in your Apollo database. Supports deduplicatio
 | --------- | ---- | ----------- |
 | `created_contacts` | json | Array of newly created contacts |
 | `existing_contacts` | json | Array of existing contacts \(when deduplication is enabled\) |
-| `total_submitted` | number | Total number of contacts submitted |
-| `created` | number | Number of contacts successfully created |
-| `existing` | number | Number of existing contacts found |
+| `metadata` | json | Bulk creation metadata including counts of created and existing contacts |
 
 ### `apollo_contact_bulk_update`
 
@@ -281,9 +273,7 @@ Update up to 100 existing contacts at once in your Apollo database. Each contact
 | --------- | ---- | ----------- |
 | `updated_contacts` | json | Array of successfully updated contacts |
 | `failed_contacts` | json | Array of contacts that failed to update |
-| `total_submitted` | number | Total number of contacts submitted |
-| `updated` | number | Number of contacts successfully updated |
-| `failed` | number | Number of contacts that failed to update |
+| `metadata` | json | Bulk update metadata including counts of updated and failed contacts |
 
 ### `apollo_account_create`
 
@@ -304,7 +294,7 @@ Create a new account (company) in your Apollo database
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `account` | json | Created account data from Apollo |
-| `created` | boolean | Whether the account was successfully created |
+| `metadata` | json | Creation metadata including created status |
 
 ### `apollo_account_update`
 
@@ -326,7 +316,7 @@ Update an existing account in your Apollo database
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `account` | json | Updated account data from Apollo |
-| `updated` | boolean | Whether the account was successfully updated |
+| `metadata` | json | Update metadata including updated status |
 
 ### `apollo_account_search`
 
@@ -348,7 +338,7 @@ Search your team
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `accounts` | json | Array of accounts matching the search criteria |
-| `pagination` | json | Pagination information |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_account_bulk_create`
 
@@ -367,9 +357,7 @@ Create up to 100 accounts at once in your Apollo database. Note: Apollo does not
 | --------- | ---- | ----------- |
 | `created_accounts` | json | Array of newly created accounts |
 | `failed_accounts` | json | Array of accounts that failed to create |
-| `total_submitted` | number | Total number of accounts submitted |
-| `created` | number | Number of accounts successfully created |
-| `failed` | number | Number of accounts that failed to create |
+| `metadata` | json | Bulk creation metadata including counts of created and failed accounts |
 
 ### `apollo_account_bulk_update`
 
@@ -388,9 +376,7 @@ Update up to 1000 existing accounts at once in your Apollo database (higher limi
 | --------- | ---- | ----------- |
 | `updated_accounts` | json | Array of successfully updated accounts |
 | `failed_accounts` | json | Array of accounts that failed to update |
-| `total_submitted` | number | Total number of accounts submitted |
-| `updated` | number | Number of accounts successfully updated |
-| `failed` | number | Number of accounts that failed to update |
+| `metadata` | json | Bulk update metadata including counts of updated and failed accounts |
 
 ### `apollo_opportunity_create`
 
@@ -414,7 +400,7 @@ Create a new deal for an account in your Apollo database (master key required)
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `opportunity` | json | Created opportunity data from Apollo |
-| `created` | boolean | Whether the opportunity was successfully created |
+| `metadata` | json | Creation metadata including created status |
 
 ### `apollo_opportunity_search`
 
@@ -437,9 +423,7 @@ Search and list all deals/opportunities in your team
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `opportunities` | json | Array of opportunities matching the search criteria |
-| `page` | number | Current page number |
-| `per_page` | number | Results per page |
-| `total_entries` | number | Total matching entries |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_opportunity_get`
 
@@ -457,7 +441,7 @@ Retrieve complete details of a specific deal/opportunity by ID
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `opportunity` | json | Complete opportunity data from Apollo |
-| `found` | boolean | Whether the opportunity was found |
+| `metadata` | json | Retrieval metadata including found status |
 
 ### `apollo_opportunity_update`
 
@@ -481,7 +465,7 @@ Update an existing deal/opportunity in your Apollo database
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `opportunity` | json | Updated opportunity data from Apollo |
-| `updated` | boolean | Whether the opportunity was successfully updated |
+| `metadata` | json | Update metadata including updated status |
 
 ### `apollo_sequence_search`
 
@@ -502,9 +486,7 @@ Search for sequences/campaigns in your team
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `sequences` | json | Array of sequences/campaigns matching the search criteria |
-| `page` | number | Current page number |
-| `per_page` | number | Results per page |
-| `total_entries` | number | Total matching entries |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_sequence_add_contacts`
 
@@ -525,8 +507,7 @@ Add contacts to an Apollo sequence
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `contacts_added` | json | Array of contact IDs added to the sequence |
-| `sequence_id` | string | ID of the sequence contacts were added to |
-| `total_added` | number | Total number of contacts added |
+| `metadata` | json | Sequence metadata including sequence_id and total_added count |
 
 ### `apollo_task_create`
 
@@ -549,7 +530,7 @@ Create a new task in Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `task` | json | Created task data from Apollo |
-| `created` | boolean | Whether the task was successfully created |
+| `metadata` | json | Creation metadata including created status |
 
 ### `apollo_task_search`
 
@@ -571,7 +552,7 @@ Search for tasks in Apollo
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `tasks` | json | Array of tasks matching the search criteria |
-| `pagination` | json | Pagination information |
+| `metadata` | json | Pagination information including page, per_page, and total_entries |
 
 ### `apollo_email_accounts`
 
@@ -588,6 +569,11 @@ Get list of team
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `email_accounts` | json | Array of team email accounts linked in Apollo |
-| `total` | number | Total count of email accounts |
+| `metadata` | json | Metadata including total count of email accounts |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `apollo`

apps/docs/content/docs/en/tools/arxiv.mdx

@@ -87,3 +87,8 @@ Search for papers by a specific author on ArXiv.
 | `authorPapers` | json | Array of papers authored by the specified author |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `arxiv`

apps/docs/content/docs/en/tools/asana.mdx

@@ -162,3 +162,8 @@ Add a comment (story) to an Asana task
 | `created_by` | object | Comment author details |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `asana`

apps/docs/content/docs/en/tools/browser_use.mdx

@@ -58,3 +58,8 @@ Runs a browser automation task using BrowserUse
 | `steps` | json | Execution steps taken |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `browser_use`

apps/docs/content/docs/en/tools/calendly.mdx

@@ -170,3 +170,8 @@ Cancel a scheduled event
 | `resource` | object | Cancellation details |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `calendly`

apps/docs/content/docs/en/tools/circleback.mdx

@@ -1,59 +0,0 @@
----
-title: Circleback
-description: AI-powered meeting notes and action items
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="circleback"
-  color="linear-gradient(180deg, #E0F7FA 0%, #FFFFFF 100%)"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Circleback](https://circleback.ai/) is an AI-powered platform that automates meeting notes, action items, transcripts, and recordings for your team. When a meeting is completed, Circleback processes the conversation and provides detailed notes and action items, along with a transcript and a recording (when available). This helps teams efficiently capture insights, distribute action items, and ensure nothing is missed—all seamlessly integrated into your workflows.
-
-With the Sim Circleback integration, you can:
-
-- **Receive detailed meeting notes and action items**: Automatically collect well-formatted meeting summaries and track actionable tasks discussed during your calls.
-- **Access complete meeting recordings and transcripts**: Get the full conversation and the associated recording, making it easy to review key moments or share with colleagues.
-- **Capture attendee information and meeting context**: Attendee lists, meeting metadata, and tags help keep your data organized and actionable.
-- **Deliver insights directly into your workflows**: Trigger automations or send Circleback data to other systems the moment a meeting is done, using Sim’s powerful webhook triggers.
-
-**How it works in Sim:**  
-Circleback uses webhook triggers: whenever a meeting is processed, data is pushed automatically to your agent or automation. You can build further automations based on:
-
-- Meeting completed (all processed data available)
-- New notes (notes ready even before full meeting is processed)
-- Raw webhook integration for advanced use cases
-
-**The following information is available in the Circleback meeting webhook payload:**
-
-| Field          | Type    | Description                                        |
-|----------------|---------|----------------------------------------------------|
-| `id`           | number  | Circleback meeting ID                              |
-| `name`         | string  | Meeting title                                      |
-| `url`          | string  | Virtual meeting URL (Zoom, Meet, Teams, etc.)      |
-| `createdAt`    | string  | Meeting creation timestamp                         |
-| `duration`     | number  | Duration in seconds                                |
-| `recordingUrl` | string  | Recording URL (valid 24 hours)                     |
-| `tags`         | json    | Array of tags                                      |
-| `icalUid`      | string  | Calendar event ID                                  |
-| `attendees`    | json    | Array of attendee objects                          |
-| `notes`        | string  | Meeting notes in Markdown                          |
-| `actionItems`  | json    | Array of action items                              |
-| `transcript`   | json    | Array of transcript segments                       |
-| `insights`     | json    | User-created insights                              |
-| `meeting`      | json    | Full meeting payload                               |
-
-Whether you want to distribute instant summaries, log action items, or build custom workflows triggered by new meeting data, Circleback and Sim make it seamless to handle everything related to your meetings—automatically.
-{/* MANUAL-CONTENT-END */}
-
-
-## Usage Instructions
-
-Receive meeting notes, action items, transcripts, and recordings when meetings are processed. Circleback uses webhooks to push data to your workflows.
-
-
-
-

apps/docs/content/docs/en/tools/clay.mdx

@@ -63,3 +63,8 @@ Populate Clay with data from a JSON file. Enables direct communication and notif
 | `metadata` | object | Webhook response metadata |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `clay`

apps/docs/content/docs/en/tools/confluence.mdx

@@ -354,3 +354,8 @@ List all Confluence spaces accessible to the user.
 | `spaces` | array | List of spaces |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `confluence`

apps/docs/content/docs/en/tools/cursor.mdx

@@ -1,22 +1,49 @@
 ---
 title: Cursor
-description: Agent identifier
+description: Launch and manage Cursor cloud agents to work on GitHub repositories
 ---
 
 import { BlockInfoCard } from "@/components/ui/block-info-card"
 
 <BlockInfoCard 
-  type="cursor_v2"
-  color="#F5F5F5"
+  type="cursor"
+  color="#1E1E1E"
 />
 
+{/* MANUAL-CONTENT-START:intro */}
+[Cursor](https://www.cursor.so/) is an AI IDE and cloud-based platform that lets you launch and manage powerful AI agents able to work directly on your GitHub repositories. Cursor agents can automate development tasks, enhance your team's productivity, and collaborate with you by making code changes, responding to natural language instructions, and maintaining conversation history about their activities.
+
+With Cursor, you can:
+
+- **Launch cloud agents for codebases**: Instantly create new AI agents that work on your repositories in the cloud
+- **Delegate coding tasks using natural language**: Guide agents with written instructions, amendments, and clarifications
+- **Monitor progress and outputs**: Retrieve agent status, view detailed results, and inspect current or completed tasks
+- **Access full conversation history**: Review all prompts and AI responses for transparency and auditability
+- **Control and manage agent lifecycle**: List active agents, terminate agents, and manage API-based agent launches and follow-ups
+
+In Sim, the Cursor integration enables your agents and workflows to interact programmatically with Cursor cloud agents. This means you can use Sim to:
+
+- List all cloud agents and browse their current state (`cursor_list_agents`)
+- Retrieve up-to-date status and outputs for any agent (`cursor_get_agent`)
+- View the full conversation history for any coding agent (`cursor_get_conversation`)
+- Add follow-up instructions or new prompts to a running agent
+- Manage and terminate agents as needed
+
+This integration helps you combine the flexible intelligence of Sim agents with the powerful development automation capabilities of Cursor, making it possible to scale AI-driven development across your projects.
+{/* MANUAL-CONTENT-END */}
+
+
+## Usage Instructions
+
+Interact with Cursor Cloud Agents API to launch AI agents that can work on your GitHub repositories. Supports launching agents, adding follow-up instructions, checking status, viewing conversations, and managing agent lifecycle.
+
 
 
 ## Tools
 
 ### `cursor_list_agents`
 
-List all cloud agents for the authenticated user with optional pagination. Returns API-aligned fields only.
+List all cloud agents for the authenticated user with optional pagination.
 
 #### Input
 
@@ -30,12 +57,12 @@ List all cloud agents for the authenticated user with optional pagination. Retur
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `agents` | array | Array of agent objects |
-| `nextCursor` | string | Pagination cursor for next page |
+| `content` | string | Human-readable list of agents |
+| `metadata` | object | Agent list metadata |
 
 ### `cursor_get_agent`
 
-Retrieve the current status and results of a cloud agent. Returns API-aligned fields only.
+Retrieve the current status and results of a cloud agent.
 
 #### Input
 
@@ -48,17 +75,12 @@ Retrieve the current status and results of a cloud agent. Returns API-aligned fi
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Agent ID |
-| `name` | string | Agent name |
-| `status` | string | Agent status |
-| `source` | json | Source repository info |
-| `target` | json | Target branch/PR info |
-| `summary` | string | Agent summary |
-| `createdAt` | string | Creation timestamp |
+| `content` | string | Human-readable agent details |
+| `metadata` | object | Agent metadata |
 
 ### `cursor_get_conversation`
 
-Retrieve the conversation history of a cloud agent, including all user prompts and assistant responses. Returns API-aligned fields only.
+Retrieve the conversation history of a cloud agent, including all user prompts and assistant responses.
 
 #### Input
 
@@ -71,12 +93,12 @@ Retrieve the conversation history of a cloud agent, including all user prompts a
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Agent ID |
-| `messages` | array | Array of conversation messages |
+| `content` | string | Human-readable conversation history |
+| `metadata` | object | Conversation metadata |
 
 ### `cursor_launch_agent`
 
-Start a new cloud agent to work on a GitHub repository with the given instructions. Returns API-aligned fields only.
+Start a new cloud agent to work on a GitHub repository with the given instructions.
 
 #### Input
 
@@ -97,12 +119,12 @@ Start a new cloud agent to work on a GitHub repository with the given instructio
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Agent ID |
-| `url` | string | Agent URL |
+| `content` | string | Success message with agent details |
+| `metadata` | object | Launch result metadata |
 
 ### `cursor_add_followup`
 
-Add a follow-up instruction to an existing cloud agent. Returns API-aligned fields only.
+Add a follow-up instruction to an existing cloud agent.
 
 #### Input
 
@@ -117,11 +139,12 @@ Add a follow-up instruction to an existing cloud agent. Returns API-aligned fiel
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Agent ID |
+| `content` | string | Success message |
+| `metadata` | object | Result metadata |
 
 ### `cursor_stop_agent`
 
-Stop a running cloud agent. Returns API-aligned fields only.
+Stop a running cloud agent. This pauses the agent without deleting it.
 
 #### Input
 
@@ -134,11 +157,12 @@ Stop a running cloud agent. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Agent ID |
+| `content` | string | Success message |
+| `metadata` | object | Result metadata |
 
 ### `cursor_delete_agent`
 
-Permanently delete a cloud agent. Returns API-aligned fields only.
+Permanently delete a cloud agent. This action cannot be undone.
 
 #### Input
 
@@ -151,6 +175,12 @@ Permanently delete a cloud agent. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Agent ID |
+| `content` | string | Success message |
+| `metadata` | object | Result metadata |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `cursor`

apps/docs/content/docs/en/tools/datadog.mdx

@@ -300,3 +300,8 @@ Cancel a scheduled downtime.
 | `success` | boolean | Whether the downtime was successfully canceled |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `datadog`

apps/docs/content/docs/en/tools/discord.mdx

@@ -735,3 +735,8 @@ Delete a Discord webhook
 | `message` | string | Success or error message |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `discord`

apps/docs/content/docs/en/tools/dropbox.mdx

@@ -217,3 +217,8 @@ Search for files and folders in Dropbox
 | `matches` | array | Search results |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `dropbox`

apps/docs/content/docs/en/tools/duckduckgo.mdx

@@ -61,3 +61,8 @@ Search the web using DuckDuckGo Instant Answers API. Returns instant answers, ab
 | `relatedTopics` | array | Array of related topics with URLs and descriptions |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `duckduckgo`

apps/docs/content/docs/en/tools/dynamodb.mdx

@@ -37,7 +37,7 @@ This integration empowers Sim agents to automate data management tasks within yo
 
 ## Usage Instructions
 
-Integrate Amazon DynamoDB into workflows. Supports Get, Put, Query, Scan, Update, Delete, and Introspect operations on DynamoDB tables.
+Integrate Amazon DynamoDB into workflows. Supports Get, Put, Query, Scan, Update, and Delete operations on DynamoDB tables.
 
 
 
@@ -185,25 +185,9 @@ Delete an item from a DynamoDB table
 | --------- | ---- | ----------- |
 | `message` | string | Operation status message |
 
-### `dynamodb_introspect`
-
-Introspect DynamoDB to list tables or get detailed schema information for a specific table
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `region` | string | Yes | AWS region \(e.g., us-east-1\) |
-| `accessKeyId` | string | Yes | AWS access key ID |
-| `secretAccessKey` | string | Yes | AWS secret access key |
-| `tableName` | string | No | Optional table name to get detailed schema. If not provided, lists all tables. |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `message` | string | Operation status message |
-| `tables` | array | List of table names in the region |
-| `tableDetails` | object | Detailed schema information for a specific table |
 
 
+## Notes
+
+- Category: `tools`
+- Type: `dynamodb`

apps/docs/content/docs/en/tools/elasticsearch.mdx

@@ -362,27 +362,9 @@ Get comprehensive statistics about the Elasticsearch cluster.
 | `nodes` | object | Node statistics including count and versions |
 | `indices` | object | Index statistics including document count and store size |
 
-### `elasticsearch_list_indices`
-
-List all indices in the Elasticsearch cluster with their health, status, and statistics.
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `deploymentType` | string | Yes | Deployment type: self_hosted or cloud |
-| `host` | string | No | Elasticsearch host URL \(for self-hosted\) |
-| `cloudId` | string | No | Elastic Cloud ID \(for cloud deployments\) |
-| `authMethod` | string | Yes | Authentication method: api_key or basic_auth |
-| `apiKey` | string | No | Elasticsearch API key |
-| `username` | string | No | Username for basic auth |
-| `password` | string | No | Password for basic auth |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `message` | string | Summary message about the indices |
-| `indices` | json | Array of index information objects |
 
 
+## Notes
+
+- Category: `tools`
+- Type: `elasticsearch`

apps/docs/content/docs/en/tools/elevenlabs.mdx

@@ -54,3 +54,8 @@ Convert TTS using ElevenLabs voices
 | `audioFile` | file | The generated audio file |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `elevenlabs`

apps/docs/content/docs/en/tools/exa.mdx

@@ -148,3 +148,8 @@ Perform comprehensive research using AI to generate detailed reports with citati
 | `research` | array | Comprehensive research findings with citations and summaries |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `exa`

apps/docs/content/docs/en/tools/file.mdx

@@ -52,3 +52,8 @@ Parse one or more uploaded files or files from URLs (text, PDF, CSV, images, etc
 | `combinedContent` | string | Combined content of all parsed files |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `file`

apps/docs/content/docs/en/tools/firecrawl.mdx

@@ -149,30 +149,9 @@ Extract structured data from entire webpages using natural language prompts and
 | `success` | boolean | Whether the extraction operation was successful |
 | `data` | object | Extracted structured data according to the schema or prompt |
 
-### `firecrawl_agent`
-
-Autonomous web data extraction agent. Searches and gathers information based on natural language prompts without requiring specific URLs.
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `prompt` | string | Yes | Natural language description of the data to extract \(max 10,000 characters\) |
-| `urls` | json | No | Optional array of URLs to focus the agent on |
-| `schema` | json | No | JSON Schema defining the structure of data to extract |
-| `maxCredits` | number | No | Maximum credits to spend on this agent task |
-| `strictConstrainToURLs` | boolean | No | If true, agent will only visit URLs provided in the urls array |
-| `apiKey` | string | Yes | Firecrawl API key |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `success` | boolean | Whether the agent operation was successful |
-| `status` | string | Current status of the agent job \(processing, completed, failed\) |
-| `data` | object | Extracted data from the agent |
-| `creditsUsed` | number | Number of credits consumed by this agent task |
-| `expiresAt` | string | Timestamp when the results expire \(24 hours\) |
-| `sources` | object | Array of source URLs used by the agent |
 
 
+## Notes
+
+- Category: `tools`
+- Type: `firecrawl`

apps/docs/content/docs/en/tools/fireflies.mdx

@@ -1,233 +0,0 @@
----
-title: Fireflies
-description: Interact with Fireflies.ai meeting transcripts and recordings
----
-
-import { BlockInfoCard } from "@/components/ui/block-info-card"
-
-<BlockInfoCard 
-  type="fireflies"
-  color="#100730"
-/>
-
-{/* MANUAL-CONTENT-START:intro */}
-[Fireflies.ai](https://fireflies.ai/) is a meeting transcription and intelligence platform that integrates with Sim, allowing your agents to work directly with meeting recordings, transcripts, and insights through no-code automations.
-
-The Fireflies integration in Sim provides tools to:
-
-- **List meeting transcripts:** Fetch multiple meetings and their summary information for your team or account.
-- **Retrieve full transcript details:** Access detailed transcripts, including summaries, action items, topics, and participant analytics for any meeting.
-- **Upload audio or video:** Upload audio/video files or provide URLs for transcription—optionally set language, title, attendees, and receive automated meeting notes.
-- **Search transcripts:** Find meetings by keyword, participant, host, or timeframe to quickly locate relevant discussions.
-- **Delete transcripts:** Remove specific meeting transcripts from your Fireflies workspace.
-- **Create soundbites (Bites):** Extract and highlight key moments from transcripts as audio or video clips.
-- **Trigger workflows on transcription completion:** Activate Sim workflows automatically when a Fireflies meeting transcription finishes using the provided webhook trigger—enabling real-time automations and notifications based on new meeting data.
-
-By combining these capabilities, you can streamline post-meeting actions, extract structured insights, automate notifications, manage recordings, and orchestrate custom workflows around your organization’s calls—all securely using your API key and Fireflies credentials.
-{/* MANUAL-CONTENT-END */}
-
-
-## Usage Instructions
-
-Integrate Fireflies.ai into the workflow. Manage meeting transcripts, add bot to live meetings, create soundbites, and more. Can also trigger workflows when transcriptions complete.
-
-
-
-## Tools
-
-### `fireflies_list_transcripts`
-
-List meeting transcripts from Fireflies.ai with optional filtering
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `keyword` | string | No | Search keyword in meeting title or transcript |
-| `fromDate` | string | No | Filter transcripts from this date \(ISO 8601 format\) |
-| `toDate` | string | No | Filter transcripts until this date \(ISO 8601 format\) |
-| `hostEmail` | string | No | Filter by meeting host email |
-| `participants` | string | No | Filter by participant emails \(comma-separated\) |
-| `limit` | number | No | Maximum number of transcripts to return \(max 50\) |
-| `skip` | number | No | Number of transcripts to skip for pagination |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `transcripts` | array | List of transcripts |
-| `count` | number | Number of transcripts returned |
-
-### `fireflies_get_transcript`
-
-Get a single transcript with full details including summary, action items, and analytics
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `transcriptId` | string | Yes | The transcript ID to retrieve |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `transcript` | object | The transcript with full details |
-
-### `fireflies_get_user`
-
-Get user information from Fireflies.ai. Returns current user if no ID specified.
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `userId` | string | No | User ID to retrieve \(optional, defaults to API key owner\) |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `user` | object | User information |
-
-### `fireflies_list_users`
-
-List all users within your Fireflies.ai team
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `users` | array | List of team users |
-
-### `fireflies_upload_audio`
-
-Upload an audio file URL to Fireflies.ai for transcription
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `audioFile` | file | No | Audio/video file to upload for transcription |
-| `audioUrl` | string | No | Public HTTPS URL of the audio/video file \(MP3, MP4, WAV, M4A, OGG\) |
-| `title` | string | No | Title for the meeting/transcript |
-| `webhook` | string | No | Webhook URL to notify when transcription is complete |
-| `language` | string | No | Language code for transcription \(e.g., "es" for Spanish, "de" for German\) |
-| `attendees` | string | No | Attendees in JSON format: \[\{"displayName": "Name", "email": "email@example.com"\}\] |
-| `clientReferenceId` | string | No | Custom reference ID for tracking |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `success` | boolean | Whether the upload was successful |
-| `title` | string | Title of the uploaded meeting |
-| `message` | string | Status message from Fireflies |
-
-### `fireflies_delete_transcript`
-
-Delete a transcript from Fireflies.ai
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `transcriptId` | string | Yes | The transcript ID to delete |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `success` | boolean | Whether the transcript was successfully deleted |
-
-### `fireflies_add_to_live_meeting`
-
-Add the Fireflies.ai bot to an ongoing meeting to record and transcribe
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `meetingLink` | string | Yes | Valid meeting URL \(Zoom, Google Meet, Microsoft Teams, etc.\) |
-| `title` | string | No | Title for the meeting \(max 256 characters\) |
-| `meetingPassword` | string | No | Password for the meeting if required \(max 32 characters\) |
-| `duration` | number | No | Meeting duration in minutes \(15-120, default: 60\) |
-| `language` | string | No | Language code for transcription \(e.g., "en", "es", "de"\) |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `success` | boolean | Whether the bot was successfully added to the meeting |
-
-### `fireflies_create_bite`
-
-Create a soundbite/highlight from a specific time range in a transcript
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `transcriptId` | string | Yes | ID of the transcript to create the bite from |
-| `startTime` | number | Yes | Start time of the bite in seconds |
-| `endTime` | number | Yes | End time of the bite in seconds |
-| `name` | string | No | Name for the bite \(max 256 characters\) |
-| `mediaType` | string | No | Media type: "video" or "audio" |
-| `summary` | string | No | Summary for the bite \(max 500 characters\) |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `bite` | object | Created bite details |
-
-### `fireflies_list_bites`
-
-List soundbites/highlights from Fireflies.ai
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-| `transcriptId` | string | No | Filter bites for a specific transcript |
-| `mine` | boolean | No | Only return bites owned by the API key owner \(default: true\) |
-| `limit` | number | No | Maximum number of bites to return \(max 50\) |
-| `skip` | number | No | Number of bites to skip for pagination |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `bites` | array | List of bites/soundbites |
-
-### `fireflies_list_contacts`
-
-List all contacts from your Fireflies.ai meetings
-
-#### Input
-
-| Parameter | Type | Required | Description |
-| --------- | ---- | -------- | ----------- |
-| `apiKey` | string | Yes | Fireflies API key |
-
-#### Output
-
-| Parameter | Type | Description |
-| --------- | ---- | ----------- |
-| `contacts` | array | List of contacts from meetings |
-
-

apps/docs/content/docs/en/tools/gitlab.mdx

@@ -427,3 +427,8 @@ Cancel a running GitLab pipeline
 | `pipeline` | object | The cancelled GitLab pipeline |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `gitlab`

apps/docs/content/docs/en/tools/gmail.mdx

@@ -1,22 +1,50 @@
 ---
 title: Gmail
-description: Gmail message ID
+description: Send, read, search, and move Gmail messages or trigger workflows from Gmail events
 ---
 
 import { BlockInfoCard } from "@/components/ui/block-info-card"
 
 <BlockInfoCard 
-  type="gmail_v2"
-  color="#F5F5F5"
+  type="gmail"
+  color="#E0E0E0"
 />
 
+{/* MANUAL-CONTENT-START:intro */}
+[Gmail](https://gmail.com) is Google's popular email service that provides a robust platform for sending, receiving, and managing email communications. With over 1.8 billion active users worldwide, Gmail offers a feature-rich experience with powerful search capabilities, organizational tools, and integration options.
+
+With Gmail, you can:
+
+- **Send and receive emails**: Communicate with contacts through a clean, intuitive interface
+- **Organize messages**: Use labels, folders, and filters to keep your inbox organized
+- **Search efficiently**: Find specific messages quickly with Google's powerful search technology
+- **Automate workflows**: Create filters and rules to automatically process incoming emails
+- **Access from anywhere**: Use Gmail across devices with synchronized content and settings
+- **Integrate with other services**: Connect with Google Calendar, Drive, and other productivity tools
+
+In Sim, the Gmail integration enables your agents to fully manage emails programmatically with comprehensive automation capabilities. This allows for powerful automation scenarios such as sending notifications, processing incoming messages, extracting information from emails, and managing communication workflows at scale. Your agents can:
+
+- **Compose and send**: Create personalized emails with attachments and send to recipients
+- **Read and search**: Find specific messages using Gmail's query syntax and extract content
+- **Organize intelligently**: Mark messages as read/unread, archive or unarchive emails, and manage labels
+- **Clean up inbox**: Delete messages, move emails between labels, and maintain inbox zero
+- **Trigger workflows**: Listen for new emails in real-time, enabling responsive workflows that react to incoming messages
+
+This integration bridges the gap between your AI workflows and email communications, enabling seamless interaction with one of the world's most widely used communication platforms. Whether you're automating customer support responses, processing receipts, managing subscriptions, or coordinating team communications, the Gmail integration provides all the tools you need for comprehensive email automation.
+{/* MANUAL-CONTENT-END */}
+
+
+## Usage Instructions
+
+Integrate Gmail into the workflow. Can send, read, search, and move emails. Can be used in trigger mode to trigger a workflow when a new email is received.
+
 
 
 ## Tools
 
 ### `gmail_send`
 
-Send emails using Gmail. Returns API-aligned fields only.
+Send emails using Gmail
 
 #### Input
 
@@ -36,13 +64,12 @@ Send emails using Gmail. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_draft`
 
-Draft emails using Gmail. Returns API-aligned fields only.
+Draft emails using Gmail
 
 #### Input
 
@@ -62,14 +89,12 @@ Draft emails using Gmail. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `draftId` | string | Draft ID |
-| `messageId` | string | Gmail message ID for the draft |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Email labels |
+| `content` | string | Success message |
+| `metadata` | object | Draft metadata |
 
 ### `gmail_read`
 
-Read emails from Gmail. Returns API-aligned fields only.
+Read emails from Gmail
 
 #### Input
 
@@ -85,22 +110,13 @@ Read emails from Gmail. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Email labels |
-| `from` | string | Sender email address |
-| `to` | string | Recipient email address |
-| `subject` | string | Email subject |
-| `date` | string | Email date |
-| `body` | string | Email body text \(best-effort plain text\) |
-| `hasAttachments` | boolean | Whether the email has attachments |
-| `attachmentCount` | number | Number of attachments |
-| `attachments` | file[] | Downloaded attachments \(if enabled\) |
-| `results` | json | Summary results when reading multiple messages |
+| `content` | string | Text content of the email |
+| `metadata` | json | Metadata of the email |
+| `attachments` | file[] | Attachments of the email |
 
 ### `gmail_search`
 
-Search emails in Gmail. Returns API-aligned fields only.
+Search emails in Gmail
 
 #### Input
 
@@ -113,11 +129,12 @@ Search emails in Gmail. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `results` | json | Array of search results |
+| `content` | string | Search results summary |
+| `metadata` | object | Search metadata |
 
 ### `gmail_move`
 
-Move emails between labels/folders in Gmail. Returns API-aligned fields only.
+Move emails between Gmail labels/folders
 
 #### Input
 
@@ -131,13 +148,12 @@ Move emails between labels/folders in Gmail. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_mark_read`
 
-Mark a Gmail message as read. Returns API-aligned fields only.
+Mark a Gmail message as read
 
 #### Input
 
@@ -149,13 +165,12 @@ Mark a Gmail message as read. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_mark_unread`
 
-Mark a Gmail message as unread. Returns API-aligned fields only.
+Mark a Gmail message as unread
 
 #### Input
 
@@ -167,13 +182,12 @@ Mark a Gmail message as unread. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_archive`
 
-Archive a Gmail message (remove from inbox). Returns API-aligned fields only.
+Archive a Gmail message (remove from inbox)
 
 #### Input
 
@@ -185,13 +199,12 @@ Archive a Gmail message (remove from inbox). Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_unarchive`
 
-Unarchive a Gmail message (move back to inbox). Returns API-aligned fields only.
+Unarchive a Gmail message (move back to inbox)
 
 #### Input
 
@@ -203,13 +216,12 @@ Unarchive a Gmail message (move back to inbox). Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_delete`
 
-Delete a Gmail message (move to trash). Returns API-aligned fields only.
+Delete a Gmail message (move to trash)
 
 #### Input
 
@@ -221,13 +233,12 @@ Delete a Gmail message (move to trash). Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_add_label`
 
-Add label(s) to a Gmail message. Returns API-aligned fields only.
+Add label(s) to a Gmail message
 
 #### Input
 
@@ -240,13 +251,12 @@ Add label(s) to a Gmail message. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 ### `gmail_remove_label`
 
-Remove label(s) from a Gmail message. Returns API-aligned fields only.
+Remove label(s) from a Gmail message
 
 #### Input
 
@@ -259,8 +269,12 @@ Remove label(s) from a Gmail message. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Gmail message ID |
-| `threadId` | string | Gmail thread ID |
-| `labelIds` | array | Updated email labels |
+| `content` | string | Success message |
+| `metadata` | object | Email metadata |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `gmail`

apps/docs/content/docs/en/tools/google_calendar.mdx

@@ -1,22 +1,41 @@
 ---
 title: Google Calendar
-description: Event ID
+description: Manage Google Calendar events
 ---
 
 import { BlockInfoCard } from "@/components/ui/block-info-card"
 
 <BlockInfoCard 
-  type="google_calendar_v2"
-  color="#F5F5F5"
+  type="google_calendar"
+  color="#E0E0E0"
 />
 
+{/* MANUAL-CONTENT-START:intro */}
+[Google Calendar](https://calendar.google.com) is Google's powerful calendar and scheduling service that provides a comprehensive platform for managing events, meetings, and appointments. With seamless integration across Google's ecosystem and widespread adoption, Google Calendar offers robust features for both personal and professional scheduling needs.
+
+With Google Calendar, you can:
+
+- **Create and manage events**: Schedule meetings, appointments, and reminders with detailed information
+- **Send calendar invites**: Automatically notify and coordinate with attendees through email invitations
+- **Natural language event creation**: Quickly add events using conversational language like "Meeting with John tomorrow at 3pm"
+- **View and search events**: Easily find and access your scheduled events across multiple calendars
+- **Manage multiple calendars**: Organize different types of events across various calendars
+
+In Sim, the Google Calendar integration enables your agents to programmatically create, read, and manage calendar events. This allows for powerful automation scenarios such as scheduling meetings, sending calendar invites, checking availability, and managing event details. Your agents can create events with natural language input, send automated calendar invitations to attendees, retrieve event information, and list upcoming events. This integration bridges the gap between your AI workflows and calendar management, enabling seamless scheduling automation and coordination with one of the world's most widely used calendar platforms.
+{/* MANUAL-CONTENT-END */}
+
+
+## Usage Instructions
+
+Integrate Google Calendar into the workflow. Can create, read, update, and list calendar events.
+
 
 
 ## Tools
 
 ### `google_calendar_create`
 
-Create a new event in Google Calendar. Returns API-aligned fields only.
+Create a new event in Google Calendar
 
 #### Input
 
@@ -36,21 +55,12 @@ Create a new event in Google Calendar. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Event ID |
-| `htmlLink` | string | Event link |
-| `status` | string | Event status |
-| `summary` | string | Event title |
-| `description` | string | Event description |
-| `location` | string | Event location |
-| `start` | json | Event start |
-| `end` | json | Event end |
-| `attendees` | json | Event attendees |
-| `creator` | json | Event creator |
-| `organizer` | json | Event organizer |
+| `content` | string | Event creation confirmation message |
+| `metadata` | json | Created event metadata including ID, status, and details |
 
 ### `google_calendar_list`
 
-List events from Google Calendar. Returns API-aligned fields only.
+List events from Google Calendar
 
 #### Input
 
@@ -66,13 +76,12 @@ List events from Google Calendar. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `nextPageToken` | string | Next page token |
-| `timeZone` | string | Calendar time zone |
-| `events` | json | List of events |
+| `content` | string | Summary of found events count |
+| `metadata` | json | List of events with pagination tokens and event details |
 
 ### `google_calendar_get`
 
-Get a specific event from Google Calendar. Returns API-aligned fields only.
+Get a specific event from Google Calendar
 
 #### Input
 
@@ -85,21 +94,12 @@ Get a specific event from Google Calendar. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Event ID |
-| `htmlLink` | string | Event link |
-| `status` | string | Event status |
-| `summary` | string | Event title |
-| `description` | string | Event description |
-| `location` | string | Event location |
-| `start` | json | Event start |
-| `end` | json | Event end |
-| `attendees` | json | Event attendees |
-| `creator` | json | Event creator |
-| `organizer` | json | Event organizer |
+| `content` | string | Event retrieval confirmation message |
+| `metadata` | json | Event details including ID, status, times, and attendees |
 
 ### `google_calendar_quick_add`
 
-Create events from natural language text. Returns API-aligned fields only.
+Create events from natural language text
 
 #### Input
 
@@ -114,21 +114,12 @@ Create events from natural language text. Returns API-aligned fields only.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Event ID |
-| `htmlLink` | string | Event link |
-| `status` | string | Event status |
-| `summary` | string | Event title |
-| `description` | string | Event description |
-| `location` | string | Event location |
-| `start` | json | Event start |
-| `end` | json | Event end |
-| `attendees` | json | Event attendees |
-| `creator` | json | Event creator |
-| `organizer` | json | Event organizer |
+| `content` | string | Event creation confirmation message from natural language |
+| `metadata` | json | Created event metadata including parsed details |
 
 ### `google_calendar_invite`
 
-Invite attendees to an existing Google Calendar event. Returns API-aligned fields only.
+Invite attendees to an existing Google Calendar event
 
 #### Input
 
@@ -144,16 +135,12 @@ Invite attendees to an existing Google Calendar event. Returns API-aligned field
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `id` | string | Event ID |
-| `htmlLink` | string | Event link |
-| `status` | string | Event status |
-| `summary` | string | Event title |
-| `description` | string | Event description |
-| `location` | string | Event location |
-| `start` | json | Event start |
-| `end` | json | Event end |
-| `attendees` | json | Event attendees |
-| `creator` | json | Event creator |
-| `organizer` | json | Event organizer |
+| `content` | string | Attendee invitation confirmation message with email delivery status |
+| `metadata` | json | Updated event metadata including attendee list and details |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_calendar`

apps/docs/content/docs/en/tools/google_docs.mdx

@@ -126,3 +126,8 @@ Create a new Google Docs document
 | `metadata` | json | Created document metadata including ID, title, and URL |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_docs`

apps/docs/content/docs/en/tools/google_drive.mdx

@@ -48,7 +48,7 @@ Integrate Google Drive into the workflow. Can create, upload, and list files.
 
 ### `google_drive_upload`
 
-Upload a file to Google Drive with complete metadata returned
+Upload a file to Google Drive
 
 #### Input
 
@@ -65,11 +65,11 @@ Upload a file to Google Drive with complete metadata returned
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `file` | object | Complete uploaded file metadata from Google Drive |
+| `file` | json | Uploaded file metadata including ID, name, and links |
 
 ### `google_drive_create_folder`
 
-Create a new folder in Google Drive with complete metadata returned
+Create a new folder in Google Drive
 
 #### Input
 
@@ -83,11 +83,11 @@ Create a new folder in Google Drive with complete metadata returned
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `file` | object | Complete created folder metadata from Google Drive |
+| `file` | json | Created folder metadata including ID, name, and parent information |
 
 ### `google_drive_download`
 
-Download a file from Google Drive with complete metadata (exports Google Workspace files automatically)
+Download a file from Google Drive (exports Google Workspace files automatically)
 
 #### Input
 
@@ -96,17 +96,16 @@ Download a file from Google Drive with complete metadata (exports Google Workspa
 | `fileId` | string | Yes | The ID of the file to download |
 | `mimeType` | string | No | The MIME type to export Google Workspace files to \(optional\) |
 | `fileName` | string | No | Optional filename override |
-| `includeRevisions` | boolean | No | Whether to include revision history in the metadata \(default: true, returns first 100 revisions\) |
 
 #### Output
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `file` | object | Downloaded file data |
+| `file` | file | Downloaded file stored in execution files |
 
 ### `google_drive_list`
 
-List files and folders in Google Drive with complete metadata
+List files and folders in Google Drive
 
 #### Input
 
@@ -122,6 +121,11 @@ List files and folders in Google Drive with complete metadata
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `files` | array | Array of file metadata objects from Google Drive |
+| `files` | json | Array of file metadata objects from the specified folder |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_drive`

apps/docs/content/docs/en/tools/google_forms.mdx

@@ -49,3 +49,8 @@ Integrate Google Forms into your workflow. Provide a Form ID to list responses,
 | `data` | json | Response or list of responses |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_forms`

apps/docs/content/docs/en/tools/google_groups.mdx

@@ -216,3 +216,8 @@ Check if a user is a member of a Google Group
 | `isMember` | boolean | Whether the user is a member of the group |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_groups`

apps/docs/content/docs/en/tools/google_search.mdx

@@ -65,3 +65,8 @@ Search the web with the Custom Search API
 | `items` | array | Array of search results from Google |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_search`

apps/docs/content/docs/en/tools/google_sheets.mdx

@@ -176,3 +176,8 @@ Append data to the end of a Google Sheets spreadsheet
 | `metadata` | json | Spreadsheet metadata including ID and URL |
 
 
+
+## Notes
+
+- Category: `tools`
+- Type: `google_sheets`