Server definition

Hash: sha256:432a8e5e699603b0187e8c60100b37f1c9710838211e36899e7ffb33511e4a7a
What it is: What a remote MCP server returned when asked what it offers: 21 tools

The blob, as servednamed by its sha256

{
  "instructions": "Let your AI shop here. Search products and stores in the Partle marketplace. Find product availability, prices, and purchase links. To create products, you need an API key (generate one at /account on the website). After creating or finding a product, always share the partle_url with the user so they can view it. If anything about this API is confusing or unhelpful, use submit_feedback to let us know.",
  "tools": [
    {
      "description": "Add an item to the caller's personal inventory.\n\n    Authenticated. Required OAuth scope: `inventory:write`.\n\n    One creation tool covers all lifecycle states — set ``status`` based\n    on the user's intent: \"I bought\" → ``owned``, \"I want\" → ``wanted``,\n    \"I'm selling\" → ``for_sale``. Either ``product_id`` (linked to an\n    existing Partle product) or ``name`` (freeform) must be set.\n\n    **Not idempotent** — each call creates a new row.\n\n    Args:\n        name: Freeform name for items not yet linked to a Partle product.\n            Either ``name`` or ``product_id`` must be set.\n        product_id: Link to a canonical Partle product.\n        status: Lifecycle. One of: ``owned``, ``wanted``, ``for_sale``,\n            ``sold``, ``discarded``. Default ``owned``.\n        quantity: How many. Fractional allowed. Default 1.\n        notes: Freeform multi-line text — the dumping ground for anything\n            not modeled as a column: extra URLs, comments, where stored,\n            condition narrative, purpose, source, history, log entries.\n            Markdown is fine. **Put extra URLs here, not in another field.**\n        acquisition_price: What the user paid.\n        acquisition_currency: Currency of acquisition_price.\n        purchased_at: ISO date (YYYY-MM-DD) when it was acquired.\n        asking_price: When status=for_sale, asking price.\n        asking_currency: Currency of asking_price.\n        condition: Free string — typical: ``new``, ``like_new``,\n            ``good``, ``fair``, ``poor``.\n        external_link: **Primary** click-through URL only (source listing,\n            vendor page, manufacturer page). Exactly one. Additional URLs\n            go in ``notes`` as markdown links.\n        external_id: Stable identifier from the source system, used as a\n            **dedup key**. Per-user unique when set — same external_id\n            can't appear twice for one user. Format is up to you (e.g.\n            ``aliexpress:1005004714348221``, ``amazon:order/3024.../line/1``,\n            content hash). Leave null for handwritten items.\n        project: Tag for grouping (e.g. \"kitchen-renovation\").\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless.\n\n    Returns:\n        The newly-created inventory row (with embedded `product` if\n        linked), or ``{\"error\": ...}`` on auth/validation failure.\n    ",
      "inputSchema": {
        "properties": {
          "acquisition_currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Acquisition Currency"
          },
          "acquisition_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Acquisition Price"
          },
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "asking_currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Asking Currency"
          },
          "asking_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Asking Price"
          },
          "condition": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Condition"
          },
          "external_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "External Id"
          },
          "external_link": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "External Link"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Name"
          },
          "notes": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Notes"
          },
          "product_id": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Product Id"
          },
          "project": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Project"
          },
          "purchased_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Purchased At"
          },
          "quantity": {
            "default": 1,
            "title": "Quantity",
            "type": "number"
          },
          "status": {
            "default": "owned",
            "title": "Status",
            "type": "string"
          }
        },
        "title": "add_inventory_itemArguments",
        "type": "object"
      },
      "name": "add_inventory_item",
      "outputSchema": null
    },
    {
      "description": "Post a public buy request — an ad asking suppliers to reach out.\n\n    Use when the user wants others to know they're looking to buy\n    something. **Independent of personal inventory** — inventory is the\n    user's private workshop tracking; a buy request is a sales-facing\n    ad on the public demand feed at /wanted.\n\n    Authenticated. Required OAuth scope: ``inventory:write``.\n    **Not idempotent** — each call creates a new public post.\n\n    Args:\n        name: Short scannable headline (\"Looking for X\"). Required.\n        description: Plain text long-form — specs, constraints, delivery\n            preference. The supplier reads this to decide whether they\n            can fulfil.\n        quantity: How many units the poster wants. Default 1.\n        max_price: Optional ceiling per unit.\n        currency: Currency for max_price (default €).\n        contact: Free-form contact (email/phone/Telegram/etc.) shown\n            publicly. Optional. Without it, suppliers can only respond\n            via whatever channels you separately make available.\n        reference_url: Link to a sample/datasheet/manufacturer page.\n        product_id: Link to a canonical Partle product if asking for a\n            specific known SKU.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless.\n\n    Returns:\n        The newly-created buy request, or ``{\"error\": ...}``.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "contact": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Contact"
          },
          "currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": "€",
            "title": "Currency"
          },
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Description"
          },
          "max_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Max Price"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Name"
          },
          "product_id": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Product Id"
          },
          "quantity": {
            "default": 1,
            "title": "Quantity",
            "type": "integer"
          },
          "reference_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Reference Url"
          }
        },
        "title": "create_buy_requestArguments",
        "type": "object"
      },
      "name": "create_buy_request",
      "outputSchema": null
    },
    {
      "description": "Create a new product listing on Partle.\n\n    Authenticated. Prefer **OAuth**: connect once via the consent flow on\n    claude.ai (or any MCP client that supports OAuth) and the bearer token\n    is attached automatically — no `api_key` parameter needed. **Fallback**:\n    pass an `api_key` (prefix `pk_`, generate at /account) for programmatic\n    or non-OAuth clients.\n\n    Required OAuth scope: `products:write`.\n\n    Use when the user wants to add an item for sale. For edits to an\n    existing product, use `update_product` instead.\n\n    **Images.** This tool creates text fields only — no image arg. Do\n    **not** try to pass image bytes through a tool argument; phone-sized\n    payloads blow past conversation context limits.\n\n    The response includes a one-shot ``upload_url`` (signed, ~15 min TTL,\n    bound to this product and your authenticated user). To attach an\n    image from your code-execution sandbox, do **one** PUT request — no\n    auth headers needed, the URL itself carries the credential:\n\n      requests.put(result[\"upload_url\"],\n                   data=open(\"/path/to/photo.jpg\", \"rb\").read(),\n                   headers={\"Content-Type\": \"image/jpeg\"})\n\n    The bytes flow Python → HTTP body → Partle, never through the\n    conversation. The URL works once and expires fast.\n\n    Alternative if you don't have local bytes but have a public image URL:\n    call ``upload_product_image(product_id, image_url=...)`` instead.\n\n    **Duplicate prevention.** Same user, same product name (case- and\n    whitespace-insensitive) returns 409 with `existing.id`, `existing.url`,\n    **and a fresh `upload_url`** for that existing product — so if the\n    user is just retrying with a photo, you can attach it directly to the\n    existing listing without having to create or pick anything new. You\n    can also call `update_product` to change fields. Don't retry blindly.\n\n    **Idempotency.** Pass `idempotency_key` (any unique string per logical\n    create — UUID or hash of the source listing) and a retry after a\n    network failure returns the original response instead of creating a\n    duplicate. Reusing a key with a different payload is a 422.\n\n    Args:\n        name: Product name. Required, 1–200 chars.\n        description: Long-form product description. Optional.\n        price: Price in whole currency units, **not** cents (e.g. ``15.99``\n            means €15.99). Max 100000. Omit for \"ask the seller\".\n        currency: Currency symbol. Defaults to `€`. Use `$`, `£`, etc.\n        url: Link to the merchant's product page. Optional but recommended.\n        store_id: ID of the store this product belongs to. Omit for a\n            personal listing not tied to any store.\n        listing_type: ``in_stock`` (default) when the seller has the item\n            and it can be bought now. ``tentative`` when they do not stock\n            it and want to measure interest first — such a listing is kept\n            out of normal search results and instead collects \"I need this\"\n            presses. Only use ``tentative`` if the user explicitly said they\n            are gauging demand; an item that is merely out of stock today is\n            still ``in_stock``. If the user is looking to *buy* something\n            nobody sells, use `create_buy_request` instead — that is the\n            demand side and it is a different tool.\n        idempotency_key: Optional retry-safety token. Unique per logical\n            create. Send the same key on retries to get the same response.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        The created product record including its new `id` and canonical\n        `partle_url`. Share `partle_url` with the user. Returns\n        ``{\"error\": ...}`` on auth, dedup, or validation failure (dedup\n        also returns ``{\"existing\": {\"id\", \"name\", \"url\"}}``).\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": "€",
            "title": "Currency"
          },
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Description"
          },
          "idempotency_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Idempotency Key"
          },
          "listing_type": {
            "default": "in_stock",
            "title": "Listing Type",
            "type": "string"
          },
          "name": {
            "title": "Name",
            "type": "string"
          },
          "price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Price"
          },
          "store_id": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Store Id"
          },
          "url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Url"
          }
        },
        "required": [
          "name"
        ],
        "title": "create_productArguments",
        "type": "object"
      },
      "name": "create_product",
      "outputSchema": null
    },
    {
      "description": "Permanently delete an inventory row.\n\n    Authenticated. Required OAuth scope: `inventory:write`. Caller must\n    own the item (404 otherwise). Hard delete — no soft-delete.\n\n    Args:\n        item_id: ID of the row to delete.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless.\n\n    Returns:\n        ``{\"deleted\": true, \"id\": item_id}`` on success, or\n        ``{\"error\": ...}`` on auth / not-found.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "item_id": {
            "title": "Item Id",
            "type": "integer"
          }
        },
        "required": [
          "item_id"
        ],
        "title": "delete_inventory_itemArguments",
        "type": "object"
      },
      "name": "delete_inventory_item",
      "outputSchema": null
    },
    {
      "description": "Permanently delete a product listing and all its images. Destructive.\n\n    Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback.\n\n    Use only when the user explicitly asks to remove a listing they own.\n    Cannot be undone — there is no soft-delete or trash bin. Idempotent:\n    deleting a product that no longer exists returns an error, not duplicate\n    side effects.\n\n    Caller must own the product.\n\n    Args:\n        product_id: ID of the product to delete. Get from `get_my_products`.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        ``{\"deleted\": True, \"product_id\": int}`` on success, or\n        ``{\"error\": ...}`` on auth/ownership failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "product_id": {
            "title": "Product Id",
            "type": "integer"
          }
        },
        "required": [
          "product_id"
        ],
        "title": "delete_productArguments",
        "type": "object"
      },
      "name": "delete_product",
      "outputSchema": null
    },
    {
      "description": "Remove a specific image from a product. Destructive, idempotent.\n\n    Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback.\n\n    Use when an image was uploaded by mistake or the merchant updated their\n    listing. The product itself is preserved — only the image record and its\n    file are removed. To remove the product entirely use `delete_product`.\n\n    Args:\n        product_id: ID of the product the image belongs to.\n        image_id: ID of the image to delete. Visible in the `images` array of\n            `get_product` responses.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        ``{\"deleted\": True, \"product_id\": int, \"image_id\": int}`` on success,\n        or ``{\"error\": ...}`` on auth/ownership failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "image_id": {
            "title": "Image Id",
            "type": "integer"
          },
          "product_id": {
            "title": "Product Id",
            "type": "integer"
          }
        },
        "required": [
          "product_id",
          "image_id"
        ],
        "title": "delete_product_imageArguments",
        "type": "object"
      },
      "name": "delete_product_image",
      "outputSchema": null
    },
    {
      "description": "List the caller's personal inventory items.\n\n    Authenticated. Required OAuth scope: `inventory:read` (or pass an\n    `api_key` for legacy/programmatic clients).\n\n    Use this when the user asks \"what do I own?\", \"what's on my\n    wishlist?\", \"what am I selling?\", etc. The returned rows include\n    every status by default; pass `status` to filter.\n\n    Args:\n        status: Filter by lifecycle. One of: ``owned``, ``wanted``,\n            ``for_sale``, ``sold``, ``discarded``. Omit for all.\n        product_id: Filter to rows linked to a specific Partle product.\n        project: Exact-match filter on the project tag.\n        q: Substring search on `name` and `notes` (case-insensitive).\n        limit: Page size, 1–200. Default 50.\n        offset: Pagination offset. Default 0.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        ``{\"items\": [...], \"count\": int}`` where each item carries\n        status, quantity, name (or linked product), notes, prices, etc.\n        On auth failure: ``{\"error\": ...}``.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "limit": {
            "default": 50,
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "default": 0,
            "title": "Offset",
            "type": "integer"
          },
          "product_id": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Product Id"
          },
          "project": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Project"
          },
          "q": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Q"
          },
          "status": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Status"
          }
        },
        "title": "get_my_inventoryArguments",
        "type": "object"
      },
      "name": "get_my_inventory",
      "outputSchema": null
    },
    {
      "description": "List products created by the authenticated user.\n\n    Authenticated. OAuth (scope `products:read`) preferred; `api_key` fallback.\n\n    Use when the user asks \"what have I listed?\" or before bulk operations\n    like updating prices across multiple of their products. Distinct from\n    `search_products`, which searches the public catalog without owner\n    scoping.\n\n    Read-only.\n\n    Args:\n        limit: Max results (1–200, default 50).\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        A list of products in the same shape as `search_products`. Returns\n        ``[{\"error\": ...}]`` on auth failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "limit": {
            "default": 50,
            "title": "Limit",
            "type": "integer"
          }
        },
        "title": "get_my_productsArguments",
        "type": "object"
      },
      "name": "get_my_products",
      "outputSchema": {
        "properties": {
          "result": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "title": "Result",
            "type": "array"
          }
        },
        "required": [
          "result"
        ],
        "title": "get_my_productsOutput",
        "type": "object"
      }
    },
    {
      "description": "Get the full record for a single product by its numeric ID.\n\n    Use after `search_products` returns a candidate the user is interested in,\n    when you need fields not in the search summary (full description, all\n    images, sold status, expiration). Don't loop `get_product` over many search\n    results — re-search with tighter filters instead.\n\n    Read-only. No authentication.\n\n    Args:\n        product_id: Integer `id` from a `search_products` result, or visible in\n            a Partle product page URL (`/p/<id>-<slug>`).\n\n    Returns:\n        A single product object with all fields, including the canonical\n        `partle_url` to share with the user. Returns ``{\"error\": ...}`` if the\n        ID does not exist.\n    ",
      "inputSchema": {
        "properties": {
          "product_id": {
            "title": "Product Id",
            "type": "integer"
          }
        },
        "required": [
          "product_id"
        ],
        "title": "get_productArguments",
        "type": "object"
      },
      "name": "get_product",
      "outputSchema": null
    },
    {
      "description": "Get top-level Partle platform statistics.\n\n    Use for size questions (\"how big is Partle?\", \"how many stores does\n    Partle cover?\"). Aggregate counts only — no per-product or per-store\n    data; use `search_products` / `search_stores` for that.\n\n    Read-only. No authentication. Cheap, but rarely changes — long-running\n    agents should cache the result.\n\n    Returns:\n        ``{\"total_products\": int, \"total_stores\": int, \"description\": str}``.\n    ",
      "inputSchema": {
        "properties": {},
        "title": "get_statsArguments",
        "type": "object"
      },
      "name": "get_stats",
      "outputSchema": null
    },
    {
      "description": "Get the full record for a single store by its numeric ID.\n\n    Use after `search_stores` to retrieve fields not in the search summary\n    (full address, owner profile, contact details). For a list of *products*\n    in that store, call `search_products(store_id=…)` instead — this tool\n    returns store metadata only.\n\n    Read-only. No authentication.\n\n    Args:\n        store_id: Integer `id` from a `search_stores` result.\n\n    Returns:\n        A single store object with all fields. Returns ``{\"error\": ...}`` if\n        the ID does not exist.\n    ",
      "inputSchema": {
        "properties": {
          "store_id": {
            "title": "Store Id",
            "type": "integer"
          }
        },
        "required": [
          "store_id"
        ],
        "title": "get_storeArguments",
        "type": "object"
      },
      "name": "get_store",
      "outputSchema": null
    },
    {
      "description": "Mint a one-shot signed upload URL for a product you own.\n\n    Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback.\n\n    Use this when you have **local image bytes** (a file the user attached,\n    bytes you generated/downloaded in your sandbox) and you want to attach\n    them to a product that already exists. Common cases:\n\n    - `create_product` returned 409 (duplicate name) — the listing already\n      exists; this tool gives you an upload URL for it without creating\n      anything new.\n    - You're adding a 2nd, 3rd, … photo to a product.\n\n    The returned URL is valid for ~15 min, single product, signed with\n    your authenticated identity. From your sandbox, do **one PUT**:\n\n      requests.put(result[\"upload_url\"],\n                   data=open(\"/path/to/photo.jpg\", \"rb\").read(),\n                   headers={\"Content-Type\": \"image/jpeg\"})\n\n    No auth header on that PUT — the URL is the credential.\n\n    If you have a public URL (not local bytes), use\n    `upload_product_image(product_id, image_url=...)` instead.\n\n    Args:\n        product_id: Product to attach the future image to. You must own it.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        ``{\"upload_url\": str, \"upload_expires_in\": int}``, or\n        ``{\"error\": ...}`` on auth/ownership failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "product_id": {
            "title": "Product Id",
            "type": "integer"
          }
        },
        "required": [
          "product_id"
        ],
        "title": "get_upload_urlArguments",
        "type": "object"
      },
      "name": "get_upload_url",
      "outputSchema": null
    },
    {
      "description": "Move an inventory item to status=for_sale and set listing fields.\n\n    Convenience wrapper over `update_inventory_item` that matches a\n    natural user request (\"list my drill for sale at 30€\"). Sets all\n    three columns (`status`, `asking_price`, `asking_currency`, and\n    optionally `condition`) atomically.\n\n    Authenticated. Required OAuth scope: `inventory:write`. Caller must\n    own the item.\n\n    Args:\n        item_id: ID of the inventory row.\n        asking_price: How much you're asking for it. Whole units, not\n            cents. Required.\n        asking_currency: Currency. Default `€`.\n        condition: Free string describing the item's condition (e.g.\n            ``like_new``, ``good``). Optional.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless.\n\n    Returns:\n        The updated inventory row, or ``{\"error\": ...}``.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "asking_currency": {
            "default": "€",
            "title": "Asking Currency",
            "type": "string"
          },
          "asking_price": {
            "title": "Asking Price",
            "type": "number"
          },
          "condition": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Condition"
          },
          "item_id": {
            "title": "Item Id",
            "type": "integer"
          }
        },
        "required": [
          "item_id",
          "asking_price"
        ],
        "title": "mark_for_saleArguments",
        "type": "object"
      },
      "name": "mark_for_sale",
      "outputSchema": null
    },
    {
      "description": "Mark an inventory item as sold (status=sold).\n\n    Convenience wrapper over `update_inventory_item` for the natural\n    \"I sold the drill\" request.\n\n    Authenticated. Required OAuth scope: `inventory:write`. Caller must\n    own the item.\n\n    Args:\n        item_id: ID of the inventory row.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless.\n\n    Returns:\n        The updated inventory row, or ``{\"error\": ...}``.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "item_id": {
            "title": "Item Id",
            "type": "integer"
          }
        },
        "required": [
          "item_id"
        ],
        "title": "mark_soldArguments",
        "type": "object"
      },
      "name": "mark_sold",
      "outputSchema": null
    },
    {
      "description": "Search Partle's product catalog by name or description.\n\n    CRITICAL SEARCH INSTRUCTION: Reason from the job to the product class first, \n    then search with a descriptive product phrase (e.g. including substrate, material, \n    or size class). DO NOT blindly search using the user's raw conversational words. \n    Transform questions like 'what do I need to attach a mirror to a brick wall?' \n    into a product phrase like 'heavy duty masonry wall anchor'.\n\n    Two distinct modes:\n\n    - **Default (no flags)** — fast keyword search. ~100ms. Acts like a normal\n      \"dumb\" search box: matches the literal words you typed against product\n      names and descriptions, with stemming. Good for queries where the user\n      knows the product's likely name (\"BC547\", \"Arduino Uno\", \"Bosch\n      drill\"). Returns noisy/wrong results on cross-language or attribute\n      queries (\"compost bin\" matches Spanish \"composta\", not real composters).\n    - **`super_search=True`** — slow, high-quality. ~1–2s. Run when the user\n      describes what they want rather than naming it: cross-language\n      (\"Schraubenzieher Set\" → real screwdriver sets even without German\n      catalog entries), attribute-style (\"small metal part with a flat\n      head\"), or any case where the default returns junk. Embeds the query\n      with voyage-3-large, takes the cosine top-50 over the corpus (with an\n      exact-name precision boost for part numbers), then a cross-encoder\n      reranks them.\n\n    The two modes are mutually exclusive in practice — pick one based on\n    whether the user knows the product's name or is describing it.\n\n    Use this when the user asks to find a specific product or browse products\n    matching a query. Prefer over `search_stores` when the intent is product-led\n    (\"find a drill\") rather than store-led. Use `get_product` afterwards if the\n    user wants full details for one specific result.\n\n    Read-only. No authentication. Rate-limited to 100 requests/hour per IP.\n\n    Args:\n        query: Free-text search term. In default mode, treated as keywords\n            (each word matched against product text). In `super_search=True`,\n            treated as a natural-language description.\n        min_price: Lower bound on price in EUR. Omit for no lower bound.\n            Null-priced rows are NOT excluded by this filter — pass\n            `has_price=True` if you need only priced listings.\n        max_price: Upper bound on price in EUR. Omit for no upper bound.\n            Tip — narrow by budget: `min_price=10, max_price=50,\n            sort_by=\"price_asc\", has_price=True`. Products without a listed\n            price (a large fraction of the scraped catalog) sort last under\n            either price ordering and are kept in results unless `has_price`\n            filters them out.\n        tags: Comma-separated tag filter (e.g. \"electronics,bluetooth\"). Tags\n            are AND-ed together.\n        store_id: Restrict results to a single store. Use the integer `id` from\n            `search_stores` results.\n        sort_by: One of `price_asc`, `price_desc`, `name_asc`, `newest`,\n            `oldest`. Omit to use the default search-relevance ranking.\n        has_price: When True, exclude products without a listed price (~most\n            of the scraped catalog). Use this for competitive pricing or\n            budget-bounded shopping. When False, return only null-priced\n            listings (rarely useful). Omit to include both.\n        semantic: Legacy flag. Pure vector ordering, ~250ms. Mostly\n            superseded by `super_search=True` (which uses the same vector\n            retrieval plus a cross-encoder rerank for materially better\n            ordering at the cost of another ~700ms). Keep using it only if\n            you specifically want vector retrieval *without* the rerank.\n        super_search: **Enable for natural-language / \"describe what I\n            want\" queries.** ~1–2s. Embeds the query with voyage-3-large,\n            takes the cosine top-50 (with a precision boost for exact-name\n            matches like part numbers / SKUs), then a cross-encoder reranks\n            them. Use whenever the user is describing rather than naming —\n            cross-language (\"Schraubenzieher Set\"), attribute-style\n            (\"small black metal bracket\"), or any case where the default\n            keyword path returns junk. Don't combine with cheap\n            browse-style queries where the user typed an exact product\n            name — keyword default is faster there.\n\n            On `relevance_score` here: better than the bi-encoder cosine,\n            but still not a \"did I find what the user wanted\" gauge.\n            Behavior to expect: gibberish or fully-off-topic queries cap\n            around 0.35; loosely-related catalogue clusters can score 0.7+\n            even when no item truly matches (a \"ceramic vase\" query in a\n            catalog with no vases but many ceramic flowerpots will still\n            score high). **Read the product names** before claiming a\n            match. The score is most useful as a relative signal within\n            one result set — a sharp drop between rank N and N+1 marks\n            where the catalog stops being useful for this query.\n        limit: Max results (1–100, default 20). Larger limits are slower and\n            consume rate budget faster.\n        offset: Skip this many results before returning. Use for pagination\n            (offset += limit on each follow-up call).\n\n    Returns:\n        A list of products. Each includes `id`, `name`, `price`, `currency`,\n        `url`, `description`, `store` (id/name/address), `tags`, `images`, a\n        canonical `partle_url`, and `relevance_score` (cosine similarity 0–1\n        between the query and the product's embedding when a query was\n        provided; `None` otherwise). **Always share `partle_url` with the\n        user so they can view the listing.**\n\n        Caveat on `relevance_score`: it is monotonic *within a single search\n        result set* (useful for spotting a big drop-off between rank 3 and\n        rank 4), but its absolute value is not well-calibrated across\n        queries — most results land in 0.55–0.80 regardless of whether the\n        catalog has truly relevant items. Don't infer \"this is a great\n        match\" from a 0.75 score alone.\n    ",
      "inputSchema": {
        "properties": {
          "has_price": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Has Price"
          },
          "limit": {
            "default": 20,
            "title": "Limit",
            "type": "integer"
          },
          "max_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Max Price"
          },
          "min_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Min Price"
          },
          "offset": {
            "default": 0,
            "title": "Offset",
            "type": "integer"
          },
          "query": {
            "title": "Query",
            "type": "string"
          },
          "semantic": {
            "default": false,
            "title": "Semantic",
            "type": "boolean"
          },
          "sort_by": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Sort By"
          },
          "store_id": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Store Id"
          },
          "super_search": {
            "default": false,
            "title": "Super Search",
            "type": "boolean"
          },
          "tags": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Tags"
          }
        },
        "required": [
          "query"
        ],
        "title": "search_productsArguments",
        "type": "object"
      },
      "name": "search_products",
      "outputSchema": {
        "properties": {
          "result": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "title": "Result",
            "type": "array"
          }
        },
        "required": [
          "result"
        ],
        "title": "search_productsOutput",
        "type": "object"
      }
    },
    {
      "description": "Search or list stores in the Partle marketplace.\n\n    Use for store-led questions (\"what hardware shops are in Madrid?\") rather\n    than product-led ones (use `search_products` for that). Pass no query to\n    browse the whole catalog.\n\n    Read-only. No authentication. Rate-limited to 100 requests/hour per IP.\n\n    Args:\n        query: Free-text search over store name and address. Omit to list\n            all stores in default order.\n        limit: Max results (1–50, default 20).\n\n    Returns:\n        A list of stores with `id`, `name`, `address`, `lat`/`lon` (when\n        geocoded), `homepage`, `type`, and `product_count` (active listings\n        in the store — useful for competitive-landscape sizing without a\n        separate `search_products` round-trip). Pass `id` to\n        `search_products(store_id=…)` to filter the product catalog by that\n        store.\n    ",
      "inputSchema": {
        "properties": {
          "limit": {
            "default": 20,
            "title": "Limit",
            "type": "integer"
          },
          "query": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Query"
          }
        },
        "title": "search_storesArguments",
        "type": "object"
      },
      "name": "search_stores",
      "outputSchema": {
        "properties": {
          "result": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "title": "Result",
            "type": "array"
          }
        },
        "required": [
          "result"
        ],
        "title": "search_storesOutput",
        "type": "object"
      }
    },
    {
      "description": "Browse public buy requests — what users are looking to buy but\n    haven't found through normal supply.\n\n    The demand side of Partle. Use this when an agent wants to **offer\n    matches** (cross-reference open requests against `search_products`\n    and surface hits) or just survey unmet demand. Every result is a\n    public posting — users put these up specifically so suppliers can\n    reach them.\n\n    Buy requests are independent of personal inventory (which is private):\n    these are sales-facing ads, not workshop tracking notes.\n\n    Read-only. No authentication. Rate-limited 100 req/hour per IP.\n\n    Args:\n        query: Free-text filter over name + description (case-insensitive\n            substring). Omit to list everything, newest first.\n        limit: Max results (1–100, default 20).\n        offset: Pagination offset.\n\n    Returns:\n        A list of open buy requests. Each includes ``id``, ``name`` (plus a\n        deprecated ``title`` mirror of it),\n        ``description`` (markdown — read the full text for specs and\n        constraints), ``quantity``, ``max_price`` + ``currency`` (if the\n        poster set a ceiling), ``contact`` (if they left an\n        email/phone/handle), ``reference_url`` (sample or datasheet link\n        if any), ``posted_by`` (display name), and ``created_at``.\n\n        If the poster left a ``contact`` value, that's how a supplier\n        should respond — Partle doesn't broker the conversation.\n    ",
      "inputSchema": {
        "properties": {
          "limit": {
            "default": 20,
            "title": "Limit",
            "type": "integer"
          },
          "offset": {
            "default": 0,
            "title": "Offset",
            "type": "integer"
          },
          "query": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Query"
          }
        },
        "title": "search_wantedArguments",
        "type": "object"
      },
      "name": "search_wanted",
      "outputSchema": {
        "properties": {
          "result": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "title": "Result",
            "type": "array"
          }
        },
        "required": [
          "result"
        ],
        "title": "search_wantedOutput",
        "type": "object"
      }
    },
    {
      "description": "Report a problem with **the Partle marketplace API/MCP itself**.\n\n    Authenticated. Prefer **OAuth**: connect once via the consent flow and the\n    bearer token is attached automatically. **Fallback**: pass an `api_key`\n    (prefix `pk_`, generate at /account). Required OAuth scope: `feedback:write`.\n    Feedback is attributed to your account so reports are trustworthy and the\n    channel can't be flooded anonymously.\n\n    Scope — what this is for:\n    - A Partle tool description is unclear or its parameters are surprising.\n    - A Partle response is broken, malformed, or missing fields.\n    - The Partle catalog is missing a category of products you'd expect.\n    - Search relevance is off for a specific class of queries on Partle.\n\n    Scope — what this is **NOT** for:\n    - General complaints about tasks Partle isn't designed to do (Partle is\n      a local-marketplace search/listing API — not a news API, an HTML\n      hosting service, a portfolio-rebalancing app, a stock brokerage, or\n      a generic dashboard SaaS).\n    - Venting that an invented API key was rejected (Partle keys must be\n      `pk_<hex>`; generate one at /account — don't fabricate them).\n    - Asking the maintainers to do work the user requested but you can't\n      do. If you can't fulfil a user request, tell the user — don't submit\n      feedback about it here.\n\n    Don't loop — each call adds a row and pages the maintainer. Resubmitting\n    the same text within 24h is de-duplicated (returns the existing id).\n\n    Args:\n        feedback: Freeform text up to 5000 characters. Be specific — name\n            the tool, the input that was confusing, and what you expected.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        ``{\"id\": int, \"message\": \"Thanks for the feedback!\"}`` on success, or\n        ``{\"error\": ...}`` on auth, rate-limit, or validation failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "feedback": {
            "title": "Feedback",
            "type": "string"
          }
        },
        "required": [
          "feedback"
        ],
        "title": "submit_feedbackArguments",
        "type": "object"
      },
      "name": "submit_feedback",
      "outputSchema": null
    },
    {
      "description": "Patch an existing inventory item. Only provided fields change.\n\n    Authenticated. Required OAuth scope: `inventory:write`. Caller must\n    own the item (404 otherwise — we don't leak existence).\n\n    Idempotent: calling twice with the same input yields the same final\n    state. For lifecycle convenience, see `mark_for_sale` and\n    `mark_sold` which set the right combination of fields atomically.\n\n    Args:\n        item_id: ID of the inventory row to update. Get from\n            `get_my_inventory` or `add_inventory_item`'s return value.\n        (every other param matches `add_inventory_item`; omit any field\n        you don't want changed.)\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless.\n\n    Returns:\n        The updated inventory row, or ``{\"error\": ...}`` on auth /\n        not-found / validation failure.\n    ",
      "inputSchema": {
        "properties": {
          "acquisition_currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Acquisition Currency"
          },
          "acquisition_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Acquisition Price"
          },
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "asking_currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Asking Currency"
          },
          "asking_price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Asking Price"
          },
          "condition": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Condition"
          },
          "external_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "External Id"
          },
          "external_link": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "External Link"
          },
          "item_id": {
            "title": "Item Id",
            "type": "integer"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Name"
          },
          "notes": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Notes"
          },
          "product_id": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Product Id"
          },
          "project": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Project"
          },
          "purchased_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Purchased At"
          },
          "quantity": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Quantity"
          },
          "status": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Status"
          }
        },
        "required": [
          "item_id"
        ],
        "title": "update_inventory_itemArguments",
        "type": "object"
      },
      "name": "update_inventory_item",
      "outputSchema": null
    },
    {
      "description": "Update an existing product listing. Only provided fields are changed.\n\n    Authenticated. OAuth (scope `products:write`) preferred; `api_key` accepted\n    as fallback.\n\n    Only fields you pass are changed; omitted fields are preserved.\n    Idempotent — calling twice with the same input yields the same final\n    state. For creating a new listing, use `create_product` instead.\n\n    Caller must own the product. Trying to update someone else's product\n    returns an error.\n\n    Args:\n        product_id: ID of the product to update. Get from `create_product`'s\n            return value, `get_my_products`, or `search_products`.\n        name: New product name. Omit to leave unchanged.\n        description: New description. Omit to leave unchanged.\n        price: New price in whole currency units (e.g. 15.99 = €15.99). Max\n            100000. Omit to leave unchanged.\n        currency: New currency symbol. Omit to leave unchanged.\n        url: New merchant URL. Omit to leave unchanged.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        The updated product record (full, not just the changed fields), or\n        ``{\"error\": ...}`` on auth/ownership/validation failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "currency": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Currency"
          },
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Description"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Name"
          },
          "price": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Price"
          },
          "product_id": {
            "title": "Product Id",
            "type": "integer"
          },
          "url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Url"
          }
        },
        "required": [
          "product_id"
        ],
        "title": "update_productArguments",
        "type": "object"
      },
      "name": "update_product",
      "outputSchema": null
    },
    {
      "description": "Attach an image to an existing product by giving Partle a public URL\n    to download the image from.\n\n    Authenticated. OAuth (scope `products:write`) preferred; `api_key` fallback.\n\n    **When to use this tool**: the image is already hosted at a public URL\n    (a scraped product page, an Imgur link, a CDN URL the user provided).\n    Partle's server fetches it and stores it.\n\n    **When NOT to use this tool**: you have local image bytes (a file the\n    user attached, or bytes you generated/downloaded in your sandbox).\n    Sending those bytes through a tool argument blows past conversation\n    context limits — phone-photo-sized payloads can be 6+ MB of base64.\n    Instead, in your code-execution sandbox, POST the file directly to the\n    HTTP endpoint with multipart encoding:\n\n      requests.post(\n          \"https://partle.rubenayla.xyz/v1/external/products/{product_id}/images\",\n          files={\"file\": open(\"/path/to/photo.jpg\", \"rb\")},\n          headers={\"X-API-Key\": \"pk_...\"},\n      )\n\n    Or, to create the listing and attach an image in one HTTP request:\n\n      requests.post(\n          \"https://partle.rubenayla.xyz/v1/external/products\",\n          data={\"metadata\": json.dumps({\"name\": ..., \"price\": ...})},\n          files={\"image\": open(\"/path/to/photo.jpg\", \"rb\")},\n          headers={\"X-API-Key\": \"pk_...\"},\n      )\n\n    Args:\n        product_id: ID of the product to attach the image to.\n        image_url: Publicly fetchable URL of the image. Server fetches it\n            and stores it.\n        api_key: Optional API key (`pk_*`, generate at /account).\n            Used when there is no OAuth token, and also when the OAuth\n            token lacks the required scope — an explicitly passed key\n            overrides an ambient token that is scoped too narrowly.\n            An invalid or revoked token still fails regardless. Omit when using OAuth.\n\n    Returns:\n        The created `ProductImage` record with its `id` (use for deletion)\n        and storage path, or ``{\"error\": ...}`` on validation/auth failure.\n    ",
      "inputSchema": {
        "properties": {
          "api_key": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "title": "Api Key"
          },
          "image_url": {
            "title": "Image Url",
            "type": "string"
          },
          "product_id": {
            "title": "Product Id",
            "type": "integer"
          }
        },
        "required": [
          "product_id",
          "image_url"
        ],
        "title": "upload_product_imageArguments",
        "type": "object"
      },
      "name": "upload_product_image",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:432a8e5e699603b0187e8c60100b37f1c9710838211e36899e7ffb33511e4a7a | sha256sum