{
    "name": "Pharlo",
    "description": "Pharlo MCP server — publish and manage social media content (YouTube, Facebook and more) across connected channels from your AI agent.",
    "website": "https://pharlo.io",
    "docs": "https://pharlo.io/docs",
    "mcp_server_url": "https://pharlo.io/_mcp",
    "auth": {
        "type": "oauth2"
    },
    "tool_count": 21,
    "tools": [
        {
            "name": "cancel_assignment",
            "category": "assignment",
            "description": "Cancel a pending or scheduled assignment. Cancelled assignments cannot be restarted.",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "assignmentId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants to cancel a pending or scheduled assignment before it publishes.",
            "when_not_to_use": "Do not use on published assignments — cancellation cannot un-publish. Cancelled assignments cannot be restarted.",
            "required_setup": "An assignment in a cancellable state (pending or scheduled).",
            "outputs": "The assignment object with status \"cancelled\".",
            "common_errors": [
                "404 not found — assignment does not exist",
                "409 conflict — assignment already processing or published"
            ],
            "recovery_actions": [
                "Check status with get_assignment first"
            ],
            "example_user_prompts": [
                "Cancel my scheduled post 01H...",
                "Stop that assignment from going out"
            ],
            "example_tool_calls": [
                {
                    "assignmentId": "01HASSIGNMENT000000000000001"
                }
            ],
            "example_responses": [
                {
                    "id": "01HASSIGNMENT000000000000001",
                    "status": "cancelled"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments"
            ],
            "related_rest_endpoint": "DELETE /api/v1/assignments/{id}",
            "credit_cost": 2,
            "platform_limitations": []
        },
        {
            "name": "create_assignment",
            "category": "assignment",
            "description": "Create a publishing assignment. Call get_platform_capabilities first to see supported fields.\n\n- type: video, image, link, text, reel, short, story, carousel\n- payload: JSON string with platform fields\n- scheduledAt: RFC 3339 WITH timezone offset (e.g. \"2026-04-15T18:00:00+03:00\"). Never omit timezone.\n- mediaUrl, fileContent, or uploadSessionId: exactly one is required.\n- mediaUrl is for an already public direct media URL.\n- fileContent is only for small Claude chat attachments and must be base64 encoded.\n- uploadSessionId is for large local files uploaded through create_assignment_upload_session.\n\nLarge-file workflow:\n1. If the user wants to upload a file, upload a local video, upload a YouTube video from their computer, test large-file upload, asks for an upload link, or does not have a direct public mediaUrl, do not ask for mediaUrl.\n2. First call create_assignment_upload_session(connectionId) without fileName, fileMimeType, or fileSizeBytes, then give the uploadPageUrl to the user.\n3. Do not ask for file name, MIME type, or file size. Never invent placeholder metadata; the browser upload page reads metadata from the selected local file.\n4. After the user finishes browser upload, call get_assignment_upload_session.\n5. Only after the upload session status is \"completed\", call this tool with uploadSessionId and without mediaUrl/fileContent.\n\nYouTube privacy default is \"private\" — set {\"privacy\":\"public\"} explicitly. Facebook default is \"EVERYONE\".",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "type",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "payload",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "scheduledAt",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "callbackUrl",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "idempotencyKey",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "mediaUrl",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "mediaContentType",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "mediaSizeBytes",
                    "type": "integer",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "fileContent",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "fileName",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "fileMimeType",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "uploadSessionId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants to publish or schedule a post (video, image, link, text, reel, short, story, carousel) to a connected channel.",
            "when_not_to_use": "Do not use to edit an already published post (use update_published_content) or to change a still-pending assignment (use update_assignment). For large local files, create an upload session first.",
            "required_setup": "An active connection for the target platform. Call get_platform_capabilities first to learn required payload fields. Provide exactly one media source: mediaUrl, fileContent, or uploadSessionId.",
            "outputs": "The created assignment object: id, status (usually \"pending\"), platform, connection info, scheduledAt and payload.",
            "common_errors": [
                "Exactly one of mediaUrl, fileContent, or uploadSessionId is required",
                "Invalid JSON in payload parameter",
                "Validation failed — payload missing a platform-required field",
                "402 billing_account_not_found — no billing account for the organization",
                "413 payload_too_large — fileContent exceeds the inline upload limit"
            ],
            "recovery_actions": [
                "Call get_platform_capabilities to discover required payload fields and defaults",
                "For large files, call create_assignment_upload_session and publish with uploadSessionId",
                "Ensure scheduledAt is RFC 3339 with a timezone offset",
                "Top up credits if billing reservation fails"
            ],
            "example_user_prompts": [
                "Publish this video to my YouTube channel as public",
                "Schedule this image post to Facebook for tomorrow at 6pm"
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "type": "video",
                    "payload": "{\"title\":\"Launch recap\",\"description\":\"Highlights\",\"privacy\":\"public\"}",
                    "mediaUrl": "https://cdn.example.com/launch.mp4",
                    "scheduledAt": "2026-04-15T18:00:00+03:00"
                }
            ],
            "example_responses": [
                {
                    "id": "01HASSIGNMENT000000000000001",
                    "status": "pending",
                    "platform": "youtube",
                    "scheduledAt": "2026-04-15T18:00:00+03:00"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments",
                "https://pharlo.io/docs/platforms"
            ],
            "related_rest_endpoint": "POST /api/v1/assignments",
            "credit_cost": 12,
            "platform_limitations": [
                "YouTube privacy defaults to \"private\" — set {\"privacy\":\"public\"} explicitly",
                "Facebook audience defaults to \"EVERYONE\""
            ]
        },
        {
            "name": "create_assignment_upload_session",
            "category": "assignment",
            "description": "Create a browser upload session for a large media file that will later be published as an assignment.\n\nUse this tool when the user says they want to upload a file, upload a local video, upload a video to YouTube from their computer, test large-file upload, upload through the browser, or asks for a generated upload link instead of providing a public mediaUrl.\n\nWorkflow:\n1. Ask for or infer connectionId.\n2. For the normal local/browser upload flow, call this tool with connectionId only.\n3. The browser upload page detects fileName, fileMimeType, and fileSizeBytes from the selected local file and initializes the session before upload.\n4. Do not ask the user for fileName, MIME type, or file size. Do not invent placeholder metadata. The browser determines metadata automatically.\n5. Give the returned uploadPageUrl to the user and ask them to upload the file in the browser.\n6. After the user says the upload is done, call get_assignment_upload_session with sessionId.\n7. Only when status is \"completed\", call create_assignment with uploadSessionId.\n\nDo not ask the user for a direct video URL when they explicitly want local file upload, browser upload, or large-file upload.",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": false,
                "idempotentHint": false,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "fileName",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "fileMimeType",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "fileSizeBytes",
                    "type": "integer",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants to upload a large local file through the browser (e.g. a local video to YouTube) instead of supplying a public mediaUrl, or asks for an upload link.",
            "when_not_to_use": "Do not use when the user already has a public direct media URL (publish directly with create_assignment + mediaUrl).",
            "required_setup": "An active connection. Call with connectionId only — do not ask for or invent fileName, MIME type or size; the browser upload page detects them.",
            "outputs": "An upload session with uploadPageUrl and sessionId. Give the uploadPageUrl to the user.",
            "common_errors": [
                "404 not found — assignment upload feature disabled or connection not found"
            ],
            "recovery_actions": [
                "Verify the connection with get_connection"
            ],
            "example_user_prompts": [
                "I want to upload a video from my computer to YouTube",
                "Give me an upload link for my local file"
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A"
                }
            ],
            "example_responses": [
                {
                    "sessionId": "01HUPLOADSESSION0000000000001",
                    "uploadPageUrl": "https://pharlo.io/upload/01HUPLOADSESSION0000000000001",
                    "status": "pending"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/uploads"
            ],
            "related_rest_endpoint": null,
            "credit_cost": 0,
            "platform_limitations": [
                "Do not ask the user for file name, MIME type or size — the browser provides them"
            ]
        },
        {
            "name": "get_assignment",
            "category": "assignment",
            "description": "Get details of a specific publishing assignment by ID. Returns full assignment data including:\n- status: pending | uploading | uploaded | processing | published | failed | cancelled\n- platform and connection info\n- scheduledAt (if scheduled)\n- platformPostId and platformUrl (if published)\n- errors array (if failed)\n- payload with all platform-specific fields",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "assignmentId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants the current status or full details of a specific assignment by its ID.",
            "when_not_to_use": "Do not use to list multiple assignments (use list_assignments) or to poll an upload session (use get_assignment_upload_session).",
            "required_setup": "A valid assignment ID belonging to the current API client.",
            "outputs": "Full assignment data: status, platform, connection info, scheduledAt, platformPostId and platformUrl when published, errors array when failed, and the full payload.",
            "common_errors": [
                "404 not found — assignment does not exist or belongs to another client"
            ],
            "recovery_actions": [
                "Verify the assignment ID via list_assignments"
            ],
            "example_user_prompts": [
                "What is the status of assignment 01HASSIGNMENT000000000000001?",
                "Did my scheduled YouTube post go out?"
            ],
            "example_tool_calls": [
                {
                    "assignmentId": "01HASSIGNMENT000000000000001"
                }
            ],
            "example_responses": [
                {
                    "id": "01HASSIGNMENT000000000000001",
                    "status": "published",
                    "platformUrl": "https://youtube.com/watch?v=abc123"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments"
            ],
            "related_rest_endpoint": "GET /api/v1/assignments/{id}",
            "credit_cost": 1,
            "platform_limitations": []
        },
        {
            "name": "get_assignment_upload_session",
            "category": "assignment",
            "description": "Get the current status of a browser upload session created by create_assignment_upload_session.\n\nUse this after the user uploads the file through uploadPageUrl. Check status, uploadedBytes, fileName, fileMimeType, fileSizeBytes, and completedAt.\n\nIf status is \"pending\" or \"uploading\", the upload is not ready yet. Ask the user to finish or resume the browser upload.\nIf status is \"completed\", the browser has initialized metadata and the file is ready; call create_assignment with the same sessionId as uploadSessionId.\nIf status is \"expired\", \"cancelled\", or \"consumed\", do not create a new assignment from it; create a new upload session if the user still wants to upload.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "sessionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When polling the status of a browser upload session after the user has been given the uploadPageUrl.",
            "when_not_to_use": "Do not use to fetch an assignment (use get_assignment). Only call after create_assignment_upload_session.",
            "required_setup": "A sessionId returned by create_assignment_upload_session.",
            "outputs": "Session status (pending, uploading, completed, expired, cancelled, consumed), uploadedBytes, fileName, fileMimeType, fileSizeBytes and completedAt.",
            "common_errors": [
                "404 not found — session does not exist"
            ],
            "recovery_actions": [
                "If status is pending/uploading, ask the user to finish the browser upload",
                "If status is completed, call create_assignment with uploadSessionId",
                "If status is expired/cancelled/consumed, create a new upload session"
            ],
            "example_user_prompts": [
                "Is my upload finished?",
                "Check the upload session 01HUPLOADSESSION0000000000001"
            ],
            "example_tool_calls": [
                {
                    "sessionId": "01HUPLOADSESSION0000000000001"
                }
            ],
            "example_responses": [
                {
                    "sessionId": "01HUPLOADSESSION0000000000001",
                    "status": "completed",
                    "fileName": "launch.mp4",
                    "fileSizeBytes": 524288000
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/uploads"
            ],
            "related_rest_endpoint": null,
            "credit_cost": 1,
            "platform_limitations": []
        },
        {
            "name": "list_assignments",
            "category": "assignment",
            "description": "List publishing assignments for the current API client. Supports pagination (page + limit, max 50) and optional filters.\n\nParameters:\n- page: page number (default: 1)\n- limit: items per page (default: 10, max: 50)\n- externalId: filter by external ID (exact match)\n- status: filter by assignment status — one of: pending, uploading, uploaded, processing, published, failed, cancelled\n- platform: filter by platform slug — e.g. \"youtube\", \"facebook\"\n- connectionId: filter by specific connection UUID\n- dateFrom: filter assignments created after this date (ISO 8601)\n- dateTo: filter assignments created before this date (ISO 8601)\n- compact: true (default) returns only key fields; false returns full assignment data",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "page",
                    "type": "integer",
                    "required": false,
                    "nullable": false,
                    "default": 1
                },
                {
                    "name": "limit",
                    "type": "integer",
                    "required": false,
                    "nullable": false,
                    "default": 10
                },
                {
                    "name": "externalId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "status",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "platform",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "dateFrom",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "dateTo",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "compact",
                    "type": "boolean",
                    "required": false,
                    "nullable": false,
                    "default": true
                }
            ],
            "when_to_use": "When the user wants to browse or filter their assignments (by status, platform, connection, date range or external ID).",
            "when_not_to_use": "Do not use to fetch a single known assignment (use get_assignment).",
            "required_setup": "None beyond an authenticated MCP session.",
            "outputs": "A paginated list of assignments. compact=true (default) returns key fields only; compact=false returns full payloads.",
            "common_errors": [
                "Validation failed — limit above 50 or invalid status filter"
            ],
            "recovery_actions": [
                "Keep limit at 50 or below",
                "Use a valid status value: pending, uploading, uploaded, processing, published, failed, cancelled"
            ],
            "example_user_prompts": [
                "Show my failed assignments from last week",
                "List the last 20 YouTube posts"
            ],
            "example_tool_calls": [
                {
                    "status": "failed",
                    "platform": "youtube",
                    "page": 1,
                    "limit": 20
                }
            ],
            "example_responses": [
                {
                    "page": 1,
                    "total": 3,
                    "items": [
                        {
                            "id": "01HASSIGNMENT000000000000002",
                            "status": "failed"
                        }
                    ]
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments"
            ],
            "related_rest_endpoint": "GET /api/v1/assignments",
            "credit_cost": 1,
            "platform_limitations": []
        },
        {
            "name": "retry_assignment",
            "category": "assignment",
            "description": "Retry a failed assignment. Only assignments with status \"failed\" can be retried. This re-queues the assignment for publishing — does not create a new assignment.",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "assignmentId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants to re-queue a failed assignment for publishing without recreating it.",
            "when_not_to_use": "Do not use on assignments that are not in status \"failed\". Does not create a new assignment.",
            "required_setup": "An assignment in status \"failed\". If the failure was an expired token, re-authorize the connection first via get_oauth_connect_url.",
            "outputs": "The assignment object re-queued for publishing (status returns to pending/processing).",
            "common_errors": [
                "404 not found — assignment does not exist",
                "409 conflict — assignment is not in a failed state"
            ],
            "recovery_actions": [
                "Inspect the errors array via get_assignment to understand the failure",
                "Re-authorize an expired connection before retrying"
            ],
            "example_user_prompts": [
                "Retry my failed YouTube upload",
                "Try publishing 01H... again"
            ],
            "example_tool_calls": [
                {
                    "assignmentId": "01HASSIGNMENT000000000000002"
                }
            ],
            "example_responses": [
                {
                    "id": "01HASSIGNMENT000000000000002",
                    "status": "processing"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments"
            ],
            "related_rest_endpoint": "POST /api/v1/assignments/{id}/retry",
            "credit_cost": 12,
            "platform_limitations": []
        },
        {
            "name": "update_assignment",
            "category": "assignment",
            "description": "Update a pending or uploaded assignment (scheduledAt and/or payload as JSON string).\n\n- \"pending\": change freely. \"uploaded\": can update title/description/tags and reschedule.\n- scheduledAt: RFC 3339 with timezone offset. Never omit timezone.\n- For already PUBLISHED content, use update_published_content instead.",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "assignmentId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "scheduledAt",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "payload",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants to reschedule or edit the payload of a pending or uploaded assignment before it is published.",
            "when_not_to_use": "Do not use on already published content (use update_published_content). Cannot edit cancelled or failed assignments.",
            "required_setup": "An assignment in status pending or uploaded. Provide at least one of scheduledAt or payload.",
            "outputs": "The updated assignment object reflecting the new scheduledAt and/or payload.",
            "common_errors": [
                "404 not found — assignment does not exist",
                "409 conflict — assignment is no longer editable (already processing or published)",
                "Invalid JSON in payload parameter"
            ],
            "recovery_actions": [
                "Check status with get_assignment before updating",
                "Use update_published_content for published posts"
            ],
            "example_user_prompts": [
                "Reschedule assignment 01H... to next Monday 9am",
                "Change the title on my pending video"
            ],
            "example_tool_calls": [
                {
                    "assignmentId": "01HASSIGNMENT000000000000001",
                    "scheduledAt": "2026-04-20T09:00:00+03:00",
                    "payload": "{\"title\":\"Updated title\"}"
                }
            ],
            "example_responses": [
                {
                    "id": "01HASSIGNMENT000000000000001",
                    "status": "pending",
                    "scheduledAt": "2026-04-20T09:00:00+03:00"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments"
            ],
            "related_rest_endpoint": "PATCH /api/v1/assignments/{id}",
            "credit_cost": 2,
            "platform_limitations": [
                "Uploaded assignments allow editing title/description/tags and rescheduling only"
            ]
        },
        {
            "name": "update_published_content",
            "category": "assignment",
            "description": "Update metadata of an already published assignment on the platform.\n\nCurrently supported only for YouTube. Can update:\n- title: video title (max 100 chars)\n- description: video description (max 5000 chars)\n- tags: array of tags as JSON string (e.g. '[\"tag1\",\"tag2\"]', max 500 total chars)\n- privacy: \"public\", \"unlisted\", or \"private\"\n\nThe changes are applied directly to the platform (e.g. YouTube) in real-time.\n\nNote: For pending/uploaded (not yet published) assignments, use update_assignment instead.\nNote: If the connection token is expired, re-authorize via get_oauth_connect_url first.",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "assignmentId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "title",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "description",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "tags",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "privacy",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants to edit the metadata (title, description, tags, privacy) of an already published post directly on the platform.",
            "when_not_to_use": "Do not use on pending/uploaded assignments (use update_assignment). Only YouTube is currently supported.",
            "required_setup": "A published YouTube assignment with a valid (non-expired) connection token. Provide at least one field to change.",
            "outputs": "Confirmation that the platform metadata was updated, with the applied values.",
            "common_errors": [
                "404 not found — assignment does not exist or is not published",
                "401 unauthorized — the connection token has expired",
                "Validation failed — title over 100 chars or tags over 500 total chars"
            ],
            "recovery_actions": [
                "Re-authorize the connection via get_oauth_connect_url if the token expired",
                "Trim title/description/tags to platform limits"
            ],
            "example_user_prompts": [
                "Change my published YouTube video title to 'New title'",
                "Make my uploaded video unlisted"
            ],
            "example_tool_calls": [
                {
                    "assignmentId": "01HASSIGNMENT000000000000001",
                    "title": "New title",
                    "privacy": "unlisted"
                }
            ],
            "example_responses": [
                {
                    "id": "01HASSIGNMENT000000000000001",
                    "updated": [
                        "title",
                        "privacy"
                    ]
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/assignments"
            ],
            "related_rest_endpoint": null,
            "credit_cost": 2,
            "platform_limitations": [
                "Currently supported only for YouTube",
                "title max 100 chars, description max 5000 chars, tags max 500 total chars",
                "privacy must be one of public, unlisted, private"
            ]
        },
        {
            "name": "check_oauth_status",
            "category": "connection",
            "description": "Check if a recent OAuth connection attempt has completed successfully.\n\nUse this after get_oauth_connect_url to verify whether the user has completed the OAuth authorization in their browser.\n\nParameters:\n- ticketId: the OAuth ticket ID returned by get_oauth_connect_url\n\nReturns:\n- status \"pending\" if the user has not completed the browser flow yet\n- status \"success\" with connection details if the flow completed\n- status \"failed\" with error details if the callback failed\n- status \"expired\" if the OAuth ticket expired before completion",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "ticketId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "After get_oauth_connect_url, to verify whether the user has finished the browser OAuth flow.",
            "when_not_to_use": "Do not use to start a connection (use get_oauth_connect_url).",
            "required_setup": "A ticketId returned by get_oauth_connect_url.",
            "outputs": "status pending | success (with connection details) | failed (with error) | expired.",
            "common_errors": [
                "404 not found — ticket does not exist",
                "status expired — the OAuth ticket lapsed before completion"
            ],
            "recovery_actions": [
                "If pending, ask the user to finish the browser flow, then poll again",
                "If expired or failed, call get_oauth_connect_url to start over"
            ],
            "example_user_prompts": [
                "Did my channel connect?",
                "Check OAuth ticket 01HOAUTHTICKET00000000000001"
            ],
            "example_tool_calls": [
                {
                    "ticketId": "01HOAUTHTICKET00000000000001"
                }
            ],
            "example_responses": [
                {
                    "status": "success",
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/oauth"
            ],
            "related_rest_endpoint": null,
            "credit_cost": 0,
            "platform_limitations": []
        },
        {
            "name": "get_connection",
            "category": "connection",
            "description": "Get detailed information about a specific social media connection by ID. Returns platform type, channel metadata (name, URL, subscriber count), OAuth token status (valid/expired), and configuration.\n\nIf the token is expired, use get_oauth_connect_url with the connectionId to re-authorize.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants details of a specific connection, including OAuth token status and channel metadata.",
            "when_not_to_use": "Do not use to list connections (use list_connections).",
            "required_setup": "A valid connection ID belonging to the current API client.",
            "outputs": "Platform type, channel metadata (name, URL, subscriber count), OAuth token status, and configuration.",
            "common_errors": [
                "404 not found — connection does not exist"
            ],
            "recovery_actions": [
                "Verify the connection ID via list_connections",
                "If the token is expired, re-authorize via get_oauth_connect_url with the connectionId"
            ],
            "example_user_prompts": [
                "Show details for connection 01HQ8Z9...",
                "Is my YouTube token still valid?"
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A"
                }
            ],
            "example_responses": [
                {
                    "id": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "platform": "youtube",
                    "name": "My Channel",
                    "tokenValid": false
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/connections"
            ],
            "related_rest_endpoint": "GET /api/v1/connections/{id}",
            "credit_cost": 1,
            "platform_limitations": []
        },
        {
            "name": "get_connection_stats",
            "category": "connection",
            "description": "Get current stats (followers, subscribers, views) for a specific connection. Data may be cached — returns the latest available snapshot.\n\nIf the platform API is unavailable, returns last cached values with a note about cache age.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants the current follower/subscriber/view counts for a channel (latest cached snapshot).",
            "when_not_to_use": "Do not use for per-post analytics (use get_stats or get_post_stats) or for a forced live refresh (use get_channel_stats).",
            "required_setup": "A valid connection ID.",
            "outputs": "Latest available stats snapshot (followers, subscribers, views) with a note about cache age when the platform API is unavailable.",
            "common_errors": [
                "404 not found — connection does not exist"
            ],
            "recovery_actions": [
                "Retry later if the platform API is temporarily unavailable"
            ],
            "example_user_prompts": [
                "How many subscribers does my channel have?",
                "Show stats for connection 01HQ8Z9..."
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A"
                }
            ],
            "example_responses": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "subscribers": 12450,
                    "views": 980000,
                    "cachedAt": "2026-06-02T10:00:00+00:00"
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/stats"
            ],
            "related_rest_endpoint": "GET /api/v1/connections/{id}/stats",
            "credit_cost": 1,
            "platform_limitations": [
                "Values may be cached when the platform API is unavailable"
            ]
        },
        {
            "name": "get_oauth_connect_url",
            "category": "connection",
            "description": "Get an OAuth URL to connect a YouTube or Facebook channel. User opens URL in browser, then call check_oauth_status(ticketId) to verify.\n\n- platform: \"youtube\" or \"facebook\"\n- connectionId: optional — re-authorize an existing connection\n- Returns: url, ticketId, expiresIn (15 min)",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": false,
                "idempotentHint": false,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "platform",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "organizationId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants to connect a new YouTube or Facebook channel, or re-authorize an existing connection with an expired token.",
            "when_not_to_use": "Do not use for platforms other than YouTube or Facebook.",
            "required_setup": "platform must be \"youtube\" or \"facebook\". Pass connectionId to re-authorize an existing connection.",
            "outputs": "url (open in browser), ticketId (for check_oauth_status), and expiresIn (15 minutes).",
            "common_errors": [
                "Validation failed — unsupported platform"
            ],
            "recovery_actions": [
                "Ask the user to open the returned url and complete authorization",
                "Then call check_oauth_status with the ticketId"
            ],
            "example_user_prompts": [
                "Connect my YouTube channel",
                "Re-authorize my expired Facebook connection"
            ],
            "example_tool_calls": [
                {
                    "platform": "youtube"
                }
            ],
            "example_responses": [
                {
                    "url": "https://accounts.google.com/o/oauth2/auth?...",
                    "ticketId": "01HOAUTHTICKET00000000000001",
                    "expiresIn": 900
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/connections",
                "https://pharlo.io/docs/oauth"
            ],
            "related_rest_endpoint": "POST /api/v1/oauth/tickets",
            "credit_cost": 0,
            "platform_limitations": [
                "Only YouTube and Facebook are supported",
                "The OAuth ticket expires after 15 minutes"
            ]
        },
        {
            "name": "list_connections",
            "category": "connection",
            "description": "List all social media connections (channels) for the current API client. Each connection represents an authorized social media account that can publish content.\n\nParameters:\n- page: page number (default: 1)\n- limit: items per page (default: 10, max: 50)\n- platform: filter by platform slug — e.g. \"youtube\", \"facebook\"\n- includeInactive: include deactivated connections (default: false)\n\nReturns connection id, platform, channel name, status, and whether the OAuth token is still valid.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "page",
                    "type": "integer",
                    "required": false,
                    "nullable": false,
                    "default": 1
                },
                {
                    "name": "limit",
                    "type": "integer",
                    "required": false,
                    "nullable": false,
                    "default": 10
                },
                {
                    "name": "platform",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "includeInactive",
                    "type": "boolean",
                    "required": false,
                    "nullable": false,
                    "default": false
                }
            ],
            "when_to_use": "When the user wants to see their connected social media channels and whether each token is still valid.",
            "when_not_to_use": "Do not use to fetch one known connection (use get_connection).",
            "required_setup": "None beyond an authenticated MCP session.",
            "outputs": "A paginated list of connections: id, platform, channel name, status and OAuth token validity.",
            "common_errors": [
                "Validation failed — limit above 50"
            ],
            "recovery_actions": [
                "Keep limit at 50 or below",
                "Set includeInactive=true to also see deactivated connections"
            ],
            "example_user_prompts": [
                "What channels do I have connected?",
                "List my YouTube connections"
            ],
            "example_tool_calls": [
                {
                    "platform": "youtube",
                    "includeInactive": false
                }
            ],
            "example_responses": [
                {
                    "page": 1,
                    "total": 2,
                    "items": [
                        {
                            "id": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                            "platform": "youtube",
                            "name": "My Channel",
                            "tokenValid": true
                        }
                    ]
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/connections"
            ],
            "related_rest_endpoint": "GET /api/v1/connections",
            "credit_cost": 1,
            "platform_limitations": []
        },
        {
            "name": "update_connection",
            "category": "connection",
            "description": "Update connection settings: display name and/or active status. At least one of name or isActive must be provided.\n\n- name: new display name for the connection\n- isActive: true to activate, false to deactivate (deactivated connections cannot publish)",
            "annotations": {
                "readOnlyHint": false,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "name",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "isActive",
                    "type": "boolean",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants to rename a connection or activate/deactivate it.",
            "when_not_to_use": "Do not use to re-authorize OAuth (use get_oauth_connect_url). At least one of name or isActive is required.",
            "required_setup": "A valid connection ID and at least one field to change.",
            "outputs": "The updated connection object reflecting the new name and/or active status.",
            "common_errors": [
                "404 not found — connection does not exist",
                "Validation failed — neither name nor isActive provided"
            ],
            "recovery_actions": [
                "Provide at least one of name or isActive"
            ],
            "example_user_prompts": [
                "Rename my connection to 'Brand Channel'",
                "Deactivate the Facebook connection"
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "name": "Brand Channel",
                    "isActive": true
                }
            ],
            "example_responses": [
                {
                    "id": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "name": "Brand Channel",
                    "isActive": true
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/connections"
            ],
            "related_rest_endpoint": "PATCH /api/v1/connections/{id}",
            "credit_cost": 2,
            "platform_limitations": [
                "Deactivated connections cannot publish"
            ]
        },
        {
            "name": "get_platform_capabilities",
            "category": "platform",
            "description": "Get detailed capabilities for a specific platform: supported content types, file size limits, media formats, payload fields with types/defaults/constraints, quota limits, and features.\n\nIMPORTANT: Call this before create_assignment to know exactly which payload fields are available, which are required, and what defaults will be applied.\n\nCurrently detailed capabilities are available for: youtube, facebook.\nOther platforms may be listed by list_platforms but without detailed capabilities.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "platform",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "Before create_assignment, to learn exactly which payload fields a platform supports, which are required, and the applied defaults.",
            "when_not_to_use": "Do not use to list all platforms (use list_platforms).",
            "required_setup": "A platform slug. Detailed capabilities currently exist for youtube and facebook.",
            "outputs": "Supported content types, file size limits, media formats, payload field definitions (types/defaults/constraints), quota limits and features.",
            "common_errors": [
                "404 not found — unknown platform slug",
                "Platform listed but without detailed capabilities"
            ],
            "recovery_actions": [
                "Use list_platforms to find valid slugs and which have hasCapabilities=true"
            ],
            "example_user_prompts": [
                "What fields can I set for a YouTube video?",
                "Show Facebook posting capabilities"
            ],
            "example_tool_calls": [
                {
                    "platform": "youtube"
                }
            ],
            "example_responses": [
                {
                    "platform": "youtube",
                    "contentTypes": [
                        "video",
                        "short"
                    ],
                    "payloadFields": {
                        "title": {
                            "type": "string",
                            "required": true,
                            "maxLength": 100
                        }
                    }
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/platforms"
            ],
            "related_rest_endpoint": "GET /api/v1/platforms/{platform}/capabilities",
            "credit_cost": 0,
            "platform_limitations": [
                "Detailed capabilities available only for youtube and facebook"
            ]
        },
        {
            "name": "list_platforms",
            "category": "platform",
            "description": "List all supported social media platforms with their slugs, display names, supported content types, and whether detailed capabilities are available.\n\nPlatforms with hasCapabilities=true have detailed payload field definitions — use get_platform_capabilities to see them.\n\nThis is a good first tool to call to understand what platforms are available.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [],
            "when_to_use": "A good first call to discover which platforms are supported and which content types each accepts.",
            "when_not_to_use": "Do not use for detailed payload fields of one platform (use get_platform_capabilities).",
            "required_setup": "None.",
            "outputs": "List of platforms with slug, display name, supported content types, and hasCapabilities flag.",
            "common_errors": [],
            "recovery_actions": [
                "For platforms with hasCapabilities=true, call get_platform_capabilities"
            ],
            "example_user_prompts": [
                "What platforms can I post to?",
                "Which networks does Pharlo support?"
            ],
            "example_tool_calls": [
                {}
            ],
            "example_responses": [
                {
                    "platforms": [
                        {
                            "slug": "youtube",
                            "name": "YouTube",
                            "hasCapabilities": true
                        },
                        {
                            "slug": "facebook",
                            "name": "Facebook",
                            "hasCapabilities": true
                        }
                    ]
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/platforms"
            ],
            "related_rest_endpoint": "GET /api/v1/platforms",
            "credit_cost": 0,
            "platform_limitations": []
        },
        {
            "name": "get_channel_stats",
            "category": "stats",
            "description": "Fetch live channel stats for a connection. Costs 3 credits.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": false,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants a forced live refresh of a connection's channel stats from the platform API.",
            "when_not_to_use": "Do not use when a cached snapshot is acceptable (use get_connection_stats), which is cheaper.",
            "required_setup": "A valid connection ID with a non-expired token.",
            "outputs": "Fresh channel stats fetched live from the platform.",
            "common_errors": [
                "404 not found — connection does not exist",
                "401 unauthorized — the connection token has expired"
            ],
            "recovery_actions": [
                "Re-authorize the connection via get_oauth_connect_url if the token expired"
            ],
            "example_user_prompts": [
                "Refresh my channel stats right now",
                "Get live subscriber count for connection 01HQ8Z9..."
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A"
                }
            ],
            "example_responses": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "subscribers": 12480,
                    "views": 981200
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/stats"
            ],
            "related_rest_endpoint": null,
            "credit_cost": 3,
            "platform_limitations": [
                "Live fetch depends on platform API availability"
            ]
        },
        {
            "name": "get_post_stats",
            "category": "stats",
            "description": "Fetch live post stats for a platform-native post id. Costs 2 credits.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": false,
                "openWorldHint": true
            },
            "inputs": [
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "postId",
                    "type": "string",
                    "required": true,
                    "nullable": false
                }
            ],
            "when_to_use": "When the user wants live stats for a specific platform-native post by its post ID.",
            "when_not_to_use": "Do not use for channel-level stats (use get_channel_stats) or aggregated analytics (use get_stats).",
            "required_setup": "A valid connection ID and the platform-native postId.",
            "outputs": "Live engagement stats for the given post (views, likes, comments, etc.).",
            "common_errors": [
                "404 not found — connection or post not found",
                "401 unauthorized — the connection token has expired"
            ],
            "recovery_actions": [
                "Verify the postId on the platform",
                "Re-authorize the connection if the token expired"
            ],
            "example_user_prompts": [
                "How is my latest video performing?",
                "Get stats for post abc123 on my channel"
            ],
            "example_tool_calls": [
                {
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "postId": "abc123"
                }
            ],
            "example_responses": [
                {
                    "postId": "abc123",
                    "views": 15200,
                    "likes": 540,
                    "comments": 32
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/stats"
            ],
            "related_rest_endpoint": null,
            "credit_cost": 2,
            "platform_limitations": [
                "Live fetch depends on platform API availability"
            ]
        },
        {
            "name": "get_stats",
            "category": "stats",
            "description": "Unified stats tool. Select a report type via the `report` parameter.\n\nReports:\n- overview: high-level totals (channels, posts, success rate)\n- dashboard: daily/weekly aggregates, top posts, growth\n- analytics: engagement trends, totals, top posts (80KB truncation guard)\n- recent_posts: latest published posts with stats (use `limit`, max 50)\n- subscriber_growth: follower/subscriber growth time series\n- publishing_pattern: post frequency by hour-of-day and day-of-week\n- compare: side-by-side stats for two connections (requires `connectionId` + `compareConnectionId`, must differ)\n\nCommon optional filters: platform, connectionId, dateFrom, dateTo, days.\nReport-specific: metric and contentType (analytics), limit (recent_posts), compareConnectionId (compare).",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "report",
                    "type": "string",
                    "required": true,
                    "nullable": false
                },
                {
                    "name": "platform",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "connectionId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "dateFrom",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "dateTo",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "days",
                    "type": "integer",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "metric",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "contentType",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "limit",
                    "type": "integer",
                    "required": false,
                    "nullable": true,
                    "default": null
                },
                {
                    "name": "compareConnectionId",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user wants aggregated analytics. Pick a report: overview, dashboard, analytics, recent_posts, subscriber_growth, publishing_pattern, or compare.",
            "when_not_to_use": "Do not use for a single live channel snapshot (use get_channel_stats) or a single live post (use get_post_stats).",
            "required_setup": "A report value. compare requires connectionId and compareConnectionId (must differ).",
            "outputs": "Report-specific analytics. analytics applies an ~80KB truncation guard; recent_posts honors limit (max 50).",
            "common_errors": [
                "Validation failed — unknown report value",
                "Validation failed — compare requires two distinct connection IDs"
            ],
            "recovery_actions": [
                "Use a valid report value",
                "For compare, pass connectionId and a different compareConnectionId"
            ],
            "example_user_prompts": [
                "Give me an overview of my publishing performance",
                "Compare engagement between my two channels"
            ],
            "example_tool_calls": [
                {
                    "report": "overview"
                },
                {
                    "report": "compare",
                    "connectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0A",
                    "compareConnectionId": "01HQ8Z9V2K3M4N5P6Q7R8S9T0B"
                }
            ],
            "example_responses": [
                {
                    "report": "overview",
                    "channels": 2,
                    "posts": 48,
                    "successRate": 0.96
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/stats"
            ],
            "related_rest_endpoint": "GET /api/v1/stats/{report}",
            "credit_cost": {
                "overview": 2,
                "dashboard": 2,
                "analytics": 4,
                "recent_posts": 2,
                "subscriber_growth": 2,
                "publishing_pattern": 2,
                "compare": 5
            },
            "platform_limitations": [
                "analytics responses are truncated past ~80KB",
                "recent_posts limit is capped at 50"
            ]
        },
        {
            "name": "list_webhook_deliveries",
            "category": "webhook",
            "description": "List recent webhook delivery attempts for the current API client. Shows delivery status, HTTP response codes, retry attempts, and error details.\n\nParameters:\n- status: filter by delivery status — one of: \"pending\", \"delivered\", \"failed\"\n- page: page number (default: 1)\n- limit: items per page (default: 10, max: 50)\n\nUseful for debugging webhook integration issues.",
            "annotations": {
                "readOnlyHint": true,
                "destructiveHint": false,
                "idempotentHint": true,
                "openWorldHint": false
            },
            "inputs": [
                {
                    "name": "page",
                    "type": "integer",
                    "required": false,
                    "nullable": false,
                    "default": 1
                },
                {
                    "name": "limit",
                    "type": "integer",
                    "required": false,
                    "nullable": false,
                    "default": 10
                },
                {
                    "name": "status",
                    "type": "string",
                    "required": false,
                    "nullable": true,
                    "default": null
                }
            ],
            "when_to_use": "When the user is debugging webhook integration and wants recent delivery attempts, response codes and retry history.",
            "when_not_to_use": "Do not use to manage assignments or connections.",
            "required_setup": "None beyond an authenticated MCP session. Webhooks must be configured to have deliveries.",
            "outputs": "A paginated list of webhook delivery attempts: status, HTTP response code, retry attempts and error details.",
            "common_errors": [
                "Validation failed — limit above 50 or invalid status filter"
            ],
            "recovery_actions": [
                "Use a valid status: pending, delivered, failed",
                "Keep limit at 50 or below"
            ],
            "example_user_prompts": [
                "Show my failed webhook deliveries",
                "Why aren't my webhooks arriving?"
            ],
            "example_tool_calls": [
                {
                    "status": "failed",
                    "page": 1,
                    "limit": 20
                }
            ],
            "example_responses": [
                {
                    "page": 1,
                    "total": 1,
                    "items": [
                        {
                            "id": "01HWEBHOOKDELIVERY0000000001",
                            "status": "failed",
                            "responseCode": 500,
                            "attempts": 3
                        }
                    ]
                }
            ],
            "related_docs": [
                "https://pharlo.io/docs/webhooks"
            ],
            "related_rest_endpoint": "GET /api/v1/webhooks/deliveries",
            "credit_cost": 1,
            "platform_limitations": []
        }
    ]
}