Obriym CRM

Add languages to the workspace's export languages, which gives products, categories and brands a translation tab in each of them and makes them targets for a bulk translation. Languages already offered are ignored, and none is ever removed. Use list_content_locales first to see what is offered. Idempotent. The result names what was added and echoes the workspace.

Add a line item to an existing order by its externalId. Recomputes the order total. Only allowed while the order is pending or confirmed; on any other status (processing and later, cancelled, refunded) it fails with 409 CONFLICT "Order lines can only be changed while the order is pending or confirmed". Use list_orders or create_order for the order externalId, and search_products to quote a real product. The CRM recalculates shipping eligibility from the saved priced lines; a separate whole-order discount may require source-confirmed amount correction. The result echoes the operating workspace.

Add photos to ONE product, after the photos it already has: public https image links (images, each with an optional caption), files the person attached in ChatGPT (files — ChatGPT fills it), or links returned by create_image_upload for files on the agent's own machine. Obriym downloads every image and stores its OWN COPY in the workspace's storage — the link may be temporary and nothing hotlinks to it. Limits: JPEG, PNG or WebP, at most 2 MB each (a bigger file is refused — there is no resize), at most 10 photos per product. All or nothing: if any link fails, or the total would exceed 10, nothing is stored and the reason is returned. Saves through the product form's own operation (version check, audit, channel updates). Not idempotent: repeating the call adds the photos again. Returns the product's full photo list { url, alt } — the first is the main photo. Use get_product first to see the current photos and update_product_images to reorder, caption or remove them. The result echoes the workspace.

Move a product stock by a relative delta (negative to write off, positive to add) with a reason, and record it in the stock history. This is the correct tool for a correction, a write-off or damage — it never sets an absolute number, so an order committing at the same moment is not overwritten. The reason decides the direction: write_off, damage and return_to_supplier must carry a negative delta, opening_balance a positive one, while correction and other accept either; a delta that contradicts its reason is rejected. Any other word is your own vocabulary and is accepted in either direction. The product must already track inventory; a product that does not returns a conflict rather than having tracking switched on for it. A bundle also returns a conflict: its stock is derived from its components, so adjust each component instead. Pass a stable externalId to make a retry idempotent. The new stock is pushed to every connected sales channel. The result echoes the operating workspace.

Apply a bulk price change — step 2 of 2, after preview_bulk_price_change. Send the SAME rule, scope and target and the digest the preview returned, copied verbatim and never invented. The plan is recomputed from live prices and refused with CONFLICT if it no longer matches the digest (prices moved, or the rule would compound on a retry) — preview again and show the person the new numbers. Changes real prices: a selling price reaches connected channels where the owner armed price writes; a purchase cost is never published. Returns { affected, skipped }. Needs the owner's "AI may change prices in bulk" switch (Settings → Integrations → Connect AI); without it the call is refused and you should tell the person to ask the owner. Not idempotent for percent rules — never repeat a successful apply. Confirm with the person unless they asked for the change outright. Echoes the workspace.

Archive up to 100 products — this is how an AI client removes a product. It leaves sale and every sales channel's feed, and nothing is erased: update_product with status active or draft restores it. Hard deletion is not available over MCP. A product that a non-archived bundle is made of is NOT archived: it is listed in heldByBundle with the bundles that contain it — archive or change those bundles first. Archiving also asks Prom to take the product's listings down; notAttempted counts takedowns not reached in time. To end a live eBay listing use withdraw_ebay_listings. Returns { affected, skipped, notAttempted, heldByBundle } — skipped products were already archived. Idempotent. The result echoes the workspace.

Point a brand or a supplier at its GPSR companies: the manufacturer and the EU responsible person (ids from list_economic_operators, or null to clear). Every product of that brand takes them first, then the supplier's. Replaces both roles at once. The result echoes the workspace.

Assign a lead to a workspace member by user id, or pass assignedTo=null to unassign. Use search_leads to find the lead id and get_workspace_info to confirm the operating workspace. The result echoes the operating workspace.

Choose one eBay shipping (fulfillment) policy — or null for the connection default — for up to 25 products on one eBay site, with the same per-product rules as set_product_ebay_fulfillment_policy: no listing stores the choice; a draft or live listing has its offer updated in place and read back. The policy is checked against eBay once before any product is touched, and a product whose listing lives on another eBay site fails with marketplaceMismatch instead of being moved. Returns results per product (status updated, unchanged, saved, unverified or failed with the eBay error), counts and notAttempted (not reached in the time budget — call again with those ids). Refused until the workspace owner switches on AI publishing. Idempotent. The result echoes the workspace.

Set — or clear — the BRAND of many products in one call, the way the CRM's product list bar does it. scope names the products: a list of ids (at most 100, from search_products), a model (every colour and size of it) or a category (add includeSubcategories to take the ones under it); an open filter is not accepted. A brand belongs to the model, so for a product in a model the model changes and every article of it follows — articles outside the ones named are counted in expandedByModel, never hidden. brandId comes from list_brands or create_brand (null clears the brand). Products that already have the brand are skipped. A brand called Unbranded needs no special handling: Amazon listings send it as Generic. Saved in the CRM; a live Amazon offer keeps its brand until it is updated there. Idempotent. Returns { affected, skipped, expandedByModel } and the workspace. Use update_product to change one product.

Ask Amazon whether this seller account may list a brand: allowed, approval_required (with the link to apply), not_eligible, or unknown. Amazon answers such questions per ASIN only (Listings Restrictions API) — there is no account-level brand query — so the answer is read for a SAMPLE ASIN of the brand: the one you pass, else the first catalog match whose brand equals the name. The result names the sampleAsin it was read for; when no item of the brand is found the status is unknown. Amazon has no 'application pending' state: until Amazon approves, the status stays approval_required. Reads Amazon, never writes. Use search_amazon_catalog to pick a sample ASIN, and check_amazon_readiness for a product.

Ask Amazon whether up to 25 products could be listed now — the same check as the Amazon channel page: the offline requirements (product type on the category, brand, a photo, the condition, a title of at most 75 characters), the price in the marketplace's currency, then Amazon's own dry run (VALIDATION_PREVIEW), which creates nothing. A product whose barcode Amazon already knows is checked as an OFFER on that existing item (ready rows carry its asin): only the condition and the price matter then, and a brand or category Amazon gates is refused with reason amazonListingRestricted and the approval links. Returns ready, blocked (reason, details, Amazon's sentence) and notAttemptedIds (call again with those). A blocked product's details also name what the Amazon product type still needs, found against Amazon's own schema before its dry run: missingFieldKeys (attribute keys), missingFields (their titles in the marketplace's language) and invalidFields. The CRM fills model_name (the model's code), list_price (the old price when higher, else the price, VAT included) and the item's dimensions itself; set anything else for Amazon with set_amazon_field_values (keys, kinds and allowed values from get_amazon_fields) — on the category or the model when every product shares the value. A characteristic named exactly like the field's title (upsert_product_attributes) also reaches Amazon, but characteristics are shown on the shop's site and every other channel, so keep them for real product facts. Needs a listing marketplace chosen on the Amazon connection; no arming. Then publish with publish_amazon_listings.

The model's active articles not yet on Amazon become ONE listing with variations — Amazon's "variation family"; call it a model with variations when talking to the user: a parent whose SKU is the model's code (no price, no quantity) and a child listing per article, varying by colour and/or size — the theme is chosen from what the Amazon product type declares. Every listing is first validated by Amazon (VALIDATION_PREVIEW); this tool only checks and creates nothing. Start from gaps: one entry per kind of problem with every SKU it concerns, found before Amazon is asked — size or color (set with update_product), price (none in the run's currency, the marketplace's: upsert_product_prices, set_product_channel_price or apply_bulk_price_change), productType (update_category), brand, images, condition, title; quantity with blocking=false: the article does not track stock, so the listing goes up without one (update_product with trackInventory, then adjust_stock); and barcodeLength with blocking=false: the article's barcode has another number of digits than the rest of the model, so a digit may be lost — confirm it from the label before publishing (update_product with ean). Amazon is asked only when no gap blocks. Also returns parentSku, theme, currency, blocker (tooFewArticles, noAxis, missingAxisValue, duplicateCombination, themeUnsupported, parentSkuTaken, parentTitleTooLong, tooManyArticles — the last is this CRM's limit for one run, not Amazon's: never suggest splitting the model), fieldProblems (what the product type still needs per Amazon's schema, once per field: attribute key, title in the marketplace's language, kind missing or invalid, allowed values with labels, units, the SKUs concerned, and for an attribute made of several values its parts: each part's key attribute.part, title, required, allowed values and unresolved — true when neither a person nor the CRM has an answer for it), parentIssues, children per article (missing, quantity, barcode, Amazon's sentences, status; notChecked = Amazon did not get to it, call again — what passed is kept for an hour while the article's data stays the same, so each call only checks the rest) and skipped articles (already on Amazon, taken off the channel). The CRM fills model_name, list_price, the dimensions and a size attribute (from each article's own size, with its system and class) itself; set any other field, or a part reported as unresolved, with set_amazon_field_values on the model (every article inherits it) — keys and values from get_amazon_fields. Then create it with publish_amazon_variation_family.

For a model ALREADY on Amazon as a model with variations (published with publish_amazon_variation_family): what its parent listing shows now (currentTitle) and what the CRM would send — the model's Amazon title set with set_channel_texts (modelId), else the model's name translated into the marketplace's language (titleSource model or name) — with warnings when that name would go untranslated, and Amazon's own dry run: status ready (Amazon would take it), nothing (Amazon already shows the same, nothing to send) or rejected (issues in the marketplace's language). Changes nothing. Then send it with update_amazon_variation_parent.

Check locally which products a marketplace will refuse and why — missing price, unusable price, blank name, unmapped category — grouped by what fixes them, without calling the marketplace. The response separates `blocked` (these products do NOT go out) from `warnings` (these DO go out, but probably will not be published as the merchant expects: a price in a currency the platform does not name, no words of their own in a language the channel reads, a placeholder description, characteristics the marketplace does not recognise). Local checks exist for prom, rozetka, google_merchant and olx; other platforms report their connection state through get_marketplace instead. If the channel is not connected the call fails with NOT_FOUND ("<channel> is not connected in this workspace") instead of reporting an empty channel — use list_marketplaces to see which are connected. This never publishes anything: it reports what would happen.

Mark an activity (task, call, or meeting) as completed by its id. Use list_activities first to find the activity id. The result echoes the operating workspace.

Update an existing pipeline stage's name, default probability, or WIP limit. Provide the stage id (from list_pipeline_stages) and ONLY the fields to change — omitted fields keep their current value; wipLimit null removes the limit. A name cannot be blank and must be unique among stages (409 CONFLICT otherwise). Stages cannot be created here, and stage order and terminal behavior are fixed. The result echoes the operating workspace.

Convert a lead into a contact, company, and/or deal (select at least one via the input flags). Sets the lead status to converted. Use search_leads first to find the lead id. The result echoes the operating workspace.

Create an activity (task, call, meeting, email, or note). Must link to at least one lead, contact, company, or deal — use search_leads/search_contacts/search_companies/search_deals to get the entity id. The result echoes the operating workspace.

Create a catalog brand with optional description, website and per-language description translations. The brand NAME is never translated: marketplaces match the vendor name verbatim, so send it exactly as the vendor is known. The slug is normalized to Latin. A name already used in this workspace is rejected, so call list_brands first to avoid duplicates. Translate only the brand's own description — add no facts the user did not give. The result is the created brand with its id (use it as brandId for create_product/update_product) and echoes the operating workspace.

Create a catalog category, optionally nested under an existing one, with optional description and per-language translations. The slug is normalized to Latin whatever is sent. The parent must exist in this workspace, and a name already used under the same parent is rejected, so call list_categories first to avoid duplicates. To link marketplace categories send marketplaceCategories ({ prom, rozetka, olx, amazon, google_merchant, etsy } with the id as a string, null to clear): look the ids up with search_marketplace_categories first and never guess them. The format is always checked on write, and against the marketplace while it is connected (OLX and Etsy must be a leaf category; a Google id must exist in the Google taxonomy). Translate only the category's own name and description into each locale — add no facts the user did not give. The result is the created category with its id (use it as categoryId for create_product/update_product) and echoes the operating workspace.

Create a company (B2B account). The company name must be unique in the workspace. representationState is explicitly declared (unspecified, works_alone, or has_representatives), never inferred from contacts; an individual always uses unspecified. Enforces the workspace plan limit; the result echoes the operating workspace. Use search_companies first to avoid creating a duplicate.

Create a contact (person). Use search_companies for the companyId to link an employer. Enforces the workspace plan limit and validates the company/owner links; the result echoes the operating workspace.

Create a social post as a DRAFT — nothing is published. Give it a working title, the main text, optional hashtags, the channels (each may carry its own text), and images: public https image links (Obriym stores its own copy), files the person attached in ChatGPT (the `files` field, filled by ChatGPT), links returned by create_image_upload for local files, and/or a catalog product whose photos are attached and whose sell-out later marks the live Telegram and Threads post as sold. Each channel's text, with hashtags, must fit that channel's limit (list_content_channels). Returns the post id and warnings — a channel that is not ready, Instagram without an image — to relay to the person. Not idempotent: each call creates a new draft. Then use schedule_content_post or publish_content_post. Echoes the workspace.

Create a pipeline deal. Requires a stageId, title, and next-action note. Use list_pipeline_stages for the stageId, and search_companies/search_contacts to link a company or contact. Enforces the workspace plan limit; the result echoes the operating workspace.

Create eBay DRAFT offers for up to 25 products — real writes to the seller's eBay account, but nothing is buyer-visible until publish_ebay_drafts. Run inspect_ebay_listings first and pass only products whose nextAction is create_draft and ready is true. Each product is attempted on its own: returns created, failed (each with a reason to look up in remediation.ebayPlaybook) and notAttempted (not reached in the time budget — call again with those ids). Refused until the owner switches on AI publishing, and while draft creation is not armed on the eBay connection. Not idempotent: a product that already has a draft fails with alreadyListed. The result echoes the workspace.

Create a Google Shopping campaign in the connected Google Ads account — step 2 of 2, after preview_google_shopping_campaign. A REAL write to the live ad account, but the campaign is always created PAUSED: this tool never activates or starts one, and spends nothing until a person starts it in Google Ads. It obeys the owner's own settings on the Ads page: refused unless campaign creation is armed there and the daily budget is within the owner's cap. It is also refused until the workspace owner switches on 'AI may create paused ad campaigns' (Settings → Integrations → Connect AI), and an API token is refused because it has no role — only a signed-in owner or administrator can create. Returns { campaignResourceName, status: 'PAUSED' }. Not idempotent: Google refuses a duplicate name. Never tell the user a campaign is running. Use list_ad_campaigns afterwards, once the sync has read it. The result echoes the workspace.

Get one-time links for uploading image FILES from the agent's own machine — for clients that can read local files and send HTTP requests (Claude Code, Cursor, scripts). A chat client passes image links instead, and ChatGPT passes attached files itself through the files field. For each link, send the raw file bytes with HTTP PUT within 15 minutes — for example: curl -X PUT --data-binary @photo.jpg "<uploadUrl>". One file per link; JPEG, PNG or WebP, at most 2 MB each (a bigger file is refused — there is no resize). The PUT answers JSON with url: pass that url to add_product_images (images[].url), create_content_post (imageUrls), set_category_image or set_brand_image (url), which store their own copy. Creating links changes nothing in the CRM. Returns { uploads: [{ uploadUrl, expiresAt }], maxBytes, allowedTypes }. Needs products:write or content:write.

Create a lead. Idempotent by externalId (re-sending the same externalId returns the existing lead). Requires an email or phone. Enforces the workspace plan limit; the result echoes the workspace it landed in. Use update_lead to change it afterward.

Create an order with line items. Currency is required: use trusted source facts or CRM product prices; never guess or convert. Idempotent by externalId: re-sending the same request returns the existing order. Counts toward the plan's monthly order limit (403 PLAN_LIMIT_EXCEEDED when reached). The result echoes the operating workspace. Use search_products first. For a promo code use quote_order_promotion, then send promotion.code and promotion.expectedTotal. CRM alone calculates discounts, net totals, usage limits and free shipping. Do not invent a discount, send a legacy discountAmount, or promise free shipping from your own arithmetic.

Create a catalog product. Defaults to draft status — publish it by sending status 'active' once it is complete. Use list_categories, list_brands and list_warehouses for the ids; SKU is generated when omitted and must be unique in the workspace. Set trackInventory with an opening stock to start counting units, which is recorded as the first movement in the product stock history. A bundle (type bundle with bundleItems) holds no stock of its own: its stock, tracking and cost are derived from its components, so a stock sent for it is refused and trackInventory/costPrice are ignored. If the target warehouse is set to list new products on the marketplaces, this product joins those channels. When productGroupId names an existing product model, the product joins that model as a new article and takes the model's shared content (name, description, category, brand, characteristics, translations) instead of the values sent. Enforces the workspace plan limit; the result echoes the operating workspace.

Permanently delete ONE catalog category by id. Its products are NOT deleted but lose this category (so they also drop out of marketplace feeds that require a category); its subcategories move to the top level; its translations and linked marketplace category ids are removed. NOT reversible. Not idempotent in effect: a second call for the same id returns NOT_FOUND. Call get_category first to read productCount and subcategoryCount, and confirm with the user before deleting a category that has products. The result reports productsUncategorized and subcategoriesMovedToRoot and echoes the operating workspace.

Delete a post that has not been published — a draft, a scheduled post (its schedule goes with it) or one whose every channel failed. Its own stored images are deleted too; a linked product's photos are never touched. Refused for a post that went out on any channel: that record stays. This cannot be undone. Echoes the workspace.

Delete the eBay DRAFT offer of up to 25 products; a live listing is refused — end it with withdraw_ebay_listings first. The CRM product itself is untouched. Works even while draft creation is disarmed on the connection, but still needs the owner's AI publishing switch. Returns done, failed and notAttempted. The result echoes the workspace.

Delete a model's UNPUBLISHED eBay multi-variation draft: every variation's offer and the inventory item group are removed from eBay; the articles stay on the channel, ready for a new listing (together or one by one). A live listing is refused — end it with withdraw_ebay_variation_listing first. Refused until the workspace owner switches on AI publishing. Returns deleted. The result echoes the workspace.

Work out what a bulk AI translation of products would do, step 1 of 2; nothing is written and no credits are spent. Give the products (ids, or a whole category, brand, supplier, warehouse or model) and the target languages, which must be offered by the workspace (list_content_locales). Returns how many of the selected products still need it, the most it can cost in AI credits and the credits left. Only empty fields are ever filled. Show the person this before start_catalog_translation.

Fetch one CRM activity in the selected workspace by activity id, including type, due date, completion state, assignee and linked entity. Use list_activities first when you only know the related lead/deal/contact.

The fields of the Amazon product type of ONE product, model or category (name exactly one id), read from Amazon's own schema for the workspace's Amazon marketplace: each field's attribute key, its title in the marketplace's language, its kind (choice with Amazon's list of values and labels, number, measure with the units it accepts, text), whether the type requires it, the value set on this level (own) and the one it inherits from the model or the category (inherited), and — for a product, or a model read through its first active article — its status: missing or invalid (what Amazon would refuse) or filled, and fromCrm when the CRM already fills it from the product's characteristics or fields. fields lists in full the ones that are required, missing, refused or already hold a value; otherFields names every other field by key, title and kind — pass their keys in keys to get them in full. An attribute made of several values that only mean something together (a size: shirt_size, bottoms_size, footwear_size) appears as one field per part, keyed attribute.part (shirt_size.size_system); the article's own size part is listed only for a product. Fields the CRM always writes itself (title, brand, barcode, price, photos, the colour's name, the variation relationship) are never listed. The colour's name is the product's colour in the store's language (translations on get_product, written with upsert_product_translation); which of Amazon's colour families it belongs to is the field color.standardized_values, listed for a product only, which the CRM fills from the name unless a value is set here. Use it before set_amazon_field_values; for what a product still lacks to be listed, check_amazon_readiness. Read-only: it changes nothing.

Read how the workspace's bulk AI translation is going: state (none, running, waiting for AI answers, halted when credits ran out, done), products written, credits used and the target languages. Read-only. Use start_catalog_translation to begin one and stop_catalog_translation to end it.

Fetch one catalog category by id: name, slug, parent, description, image, translations, the linked marketplace category ids (marketplaceCategories: Prom, Rozetka, OLX, Amazon, Google Merchant, each { id, label } or null), its direct subcategories (children), and productCount and subcategoryCount. Read-only. Use list_categories first to find the id, and call this before delete_category to see what a deletion would affect.

Report which products of one marketplace channel were reached by the last syncs and which were not, and why — from stored state, without calling the marketplace. Per product on the channel: state (attention = the marketplace reported a problem with the listing; never_sent = nothing recorded as sent, or no listing is linked; changed_since_sent = the product changed after it was last sent; paused = syncing paused for it; sent = sent and unchanged), a plain-language reason, lastSyncedAt (when the CRM last sent it), observedAt (when the marketplace last answered about it — null means never asked), presence, listing id, moderationStage/Action and up to 3 issues, productUpdatedAt. Also returns counts per state over the whole channel, the adapters' own last run (lastRun: matched, updated, failed, unmatched, error, lastSuccessAt and, for Google Merchant, failedSample — up to 5 refused products with Google's own message), pagination, and notStored — what the CRM does NOT keep, chiefly a reason for EVERY refused product (only the last run's sample is stored), so do not invent one. For attention, presence not_available counts only when the marketplace itself answered (observedAt set) and the channel sells; on an advertising channel (Google Merchant) it never does. Worst first; filter with state; page with page and perPage. Read-only. Use list_channel_products for price and stock on the channel and check_channel_readiness for why a product would be refused before it is sent.

Fetch one CRM company in the selected workspace by company id, including status, industry, owner and contact links when present. Use search_companies first when you only know the company name.

Fetch one CRM contact in the selected workspace by contact id, including company, owner, tags and communication fields when present. Use search_contacts first when you only know a name, email or phone.

Read one social post: its main text, hashtags, images, linked product, status and schedule, and per channel the text that channel gets (ownText or the main text), its length against the channel limit, whether the channel is ready, and what publishing returned there — status, link to the live post (permalink) or the network's error. Read-only. Use list_content_posts to find the id; call it after publish_content_post to report the links.

Fetch one CRM customer summary in the selected workspace by company id: a company that bought (a purchase order — processing, ready to ship, shipped, delivered or refunded, or with a settled payment — or a won deal that never became an order). Returns health, lifetimeValue (completed-order revenue plus won deals without an order), purchases (purchase orders plus won deals without an order), repeat (two or more purchases), lastPurchaseAt and wonDealsCount (every won deal). Read-only; a company with no purchase is not found. Use list_customers first when you only know the company name; use get_person_customer for a person who bought without a company.

Return the operational 'what needs attention today' snapshot for this workspace: active/qualified/stale lead counts, pipeline value, weighted forecast and overdue activities. Takes no arguments. Use get_report for period trend analytics instead.

Fetch one pipeline deal in the selected workspace by deal id, including stage, value, probability and linked company/contact data when present. Use search_deals first when you only know the title or related customer.

Read the eBay offers of up to 25 products live and return, per offer, the fulfillment, payment and return policy ids it carries now, the shipping policy name, its eBay site and status (PUBLISHED = live, UNPUBLISHED = draft), and matchesAssignment — whether it carries the product's own choice in the CRM (null when the product has none). Products with no draft or live listing are listed in withoutOffer; notAttempted were not reached in the time budget — call again with those ids. Reads only. Use get_product_ebay_fulfillment_policy for one product's full picture.

Show a product MODEL as one eBay multi-variation listing: state (none, draft, live), marketplaceId, listingId and listingUrl, the stable groupKey, and every article of the model with its sku, colour, size, channelState on eBay and inclusion — included, not_active, not_on_channel (put it on the channel with set_channel_membership) or single_listing (it has its own eBay draft or listing, which must be deleted or ended first). Also says whether eBay is connected and whether the owner armed listing creation. Reads the CRM only. Use inspect_ebay_variation_listing for eBay's own checks before saving.

Clicks and impressions per product in Google Shopping for a date range, best first, read from Google's Merchant API Reports on demand — nothing is stored, so it is a question, not a sync. Each row has offerId, title, clicks, impressions and clickThroughRate. At most 92 days per call and 100 products; truncated is true when more products matched than limit, so narrow the dates or raise limit. Conversions are not included. Read-only: it changes nothing at Google and needs no arming, only a connected Google account. Use get_marketplace for what Google decided about the products (moderation), and list_ad_campaigns for spend and the sales the CRM recorded.

Fetch one CRM lead in the selected workspace by lead id, including status, source, assignee, tags, custom fields, score, notes and next action. Use search_leads first when you only know a name, email, phone or company.

Read one lead's customer messages, oldest to newest: { at, channel, direction (inbound = from the customer, outbound = sent by the business), text (up to 2000 characters; truncated is true when cut), media ({ kind, contentType, name } or null — the file itself is never returned) }. A person who writes on two channels has two separate conversations: pass channel to read one, omit it to get all channels interleaved by time. Returns the most recent `limit` messages (default 30, max 100). Use it before drafting a reply or to answer what the customer asked. Read-only — this server cannot send messages. Use list_conversations to find leads with messages and get_lead for the lead card.

Fetch one connected marketplace in detail: every adapter on it with its setup state, last poll, last poll error, last catalog-sync outcome (`sync`, whose `lastSuccessAt` is the last run without a connection error — it survives failures, so it says how long a channel has been broken) and last product import, a classified `problem` (kind, needsReconnect, platformMessage, whatToDo) when anything failed, `partialFailure` ({ failed, sent, sample, whatToDo }) when the last run connected fine but the marketplace refused some products (health stays active), and for google_merchant `sync.failedSample` (up to 5 refused products with Google's own message; the reason for those only, not every refused one), plus the channel sales, leads and product counts. For google_merchant each adapter also has `moderation` — what Google decided about the products the CRM sent, as the hourly check stored it (approved, pending, limited, rejected, missing, otherTarget, offChannel, topIssues, lastCheckedAt, complete, lastError; null before the first check; complete false means only part of the catalog was read) — and `setup`: setupBlock (what stands in the way: not_connected, no_account, no_country, no_terms, not_armed — owner setup, not an outage), armed, lastPreviewAt, feedLabel, currency, termsAccepted, productUrlTemplate and contentLanguageOverride. Reads stored state only, never calls the marketplace. Use list_marketplaces first to see which platforms are connected, list_channel_products for the products on the channel and check_channel_readiness for what would be refused.

Read-only facts about Obriym CRM itself: approved marketing claims, conditions, limitations, review sources, plan prices/limits and integration scenarios/readiness with beta caveats; no customer data or external calls, and implementation review does not establish workspace configuration or customer results (empty assets means no screenshot supplied). Call before writing about Obriym, narrow by topic, use list_content_channels for publishing readiness, list_published_posts to avoid repeated topics and get_content_post to inspect a draft or publication result.

Fetch full order detail in the selected workspace by externalId, including line items, payments, shipments and returns. Use list_orders first when you only know the customer or date.

Fetch one person who bought without a company, by contact id: health, lifetimeValue (completed-order revenue plus won deals without an order), purchases, repeat, firstPurchaseAt, lastPurchaseAt and contact details. Read-only; a contact who never bought without a company is not found. Use list_people_customers or search_contacts first when you only know the name, email or phone; use get_customer for a company.

Fetch one catalog product in the selected workspace by product id or SKU — returned in any status (draft, active, or archived; check the status field) — with every catalog field: prices, cost, stock and trackInventory, availability, variant fields, all attributes (characteristics) and translations, identifiers, weight and dimensions, images, videos, bundle components and related products; plus its model, warehouse and supplier by name, supplierOffers (what the supplier last said: quantity, restock date, purchase price, state), every sales channel with its listing and moderation state, the collections it is in and its model's review summary; channelTexts (the title and bullet points written for a channel such as Amazon, per language), safetyDocuments (safety PDFs a marketplace receives) and gpsr (the manufacturer and EU responsible person with their emails, each from the brand, else the supplier). A bundle's stock and cost are derived from its components. Provide exactly one known identifier; use search_products first when unsure (search covers active products only).

Show ONE product's eBay shipping policy. Per eBay site: assignedPolicyId (the product's own choice, null when it has none), defaultPolicyId (the connection default) and effectivePolicyId with effectiveSource — product, connection_default or first_available — the policy a new draft or a go-live would carry, plus that site's policies. For a product with a draft or live listing it also reads the eBay offer live: offer.fulfillmentPolicyId is what buyers see now. Reads only. Use list_ebay_fulfillment_policies for the costs of every policy and get_ebay_offer_policies to read several products' offers at once.

Everything about ONE product's prices in one call: its own price, old price and currency; the price-list rows (other currencies); per-channel price overrides (platform, currency, price); the channel price rules that apply where there is no override (channelPriceRules); wholesale quantity breaks per currency; the purchase cost with its currency (a bundle's cost is derived from its components and cannot be set on it); and the markup over cost per sale currency (marginPercent = price ÷ cost − 1, in percent; not a margin on the price) — the cost crossed at the workspace's stated rate, null with missingRate true when no rate is stated. Read-only. Use search_products for the id; call it before set_product_channel_price, set_product_price_tiers or upsert_product_prices so you change the right row, and after a change to confirm it. For a whole group of products use preview_bulk_price_change.

Return one aggregated analytics report over a period for this workspace, selected by the report parameter: lead_source_conversion, pipeline_velocity, team_performance, revenue_trend, product_sales (units, revenue and gross margin per brand/category/SKU) or stock_valuation (units on hand and their value per warehouse, per cost currency). Each returns aggregated rows (no per-record data); days tunes the look-back for lead_source_conversion, team_performance and product_sales, months the span for revenue_trend; pipeline_velocity and stock_valuation take no period. Use get_dashboard_overview for today's operational snapshot instead.

Show which account and workspace this connection operates: signed-in name/email (OAuth only), workspace name, plan, connection type and granted scopes — what this connection may do right now (capabilities: aiSwitches, the owner's switches for AI marketplace publishing, social publishing, bulk price changes and bulk translation, each with allowedNow = switch on AND scope granted; marketplaces, each connected channel with the write directions its owner armed, and for Amazon which stores are open for listing creation, photos/GPSR, and price and stock) — so check it before a write instead of learning from a refusal — and the server itself: its version and every tool it has now (server.tools), with how to refresh an AI app whose tool list is older (server.refreshHint). Call this when the user asks 'which account or workspace am I connected to?', and when the user asks for something your tool list has no tool for: if server.tools has it, your list is outdated — relay server.refreshHint instead of saying Obriym cannot do it. Sign-in connections can use list_workspaces and select_workspace to see or change the bound workspace.

Report how the workspace's Amazon offers stand for a buyer and what Amazon says is wrong with them. Per product linked to an Amazon listing: stage (active; search_suppressed = buyable but hidden from search, usually no main image; inactive = Seller Central's 'Non attivo'; no_offer = the listing exists but Amazon shows no offer on it yet (Seller Central's 'Offerta mancante'), usual for a few hours after it is created, so re-check before changing anything; suppressed = taken down by Amazon; missing = no offer under that SKU any more; null = never checked), action (fix_issues when Amazon reports an ERROR), issues (code, severity, message, the attributes involved, Amazon's enforcement such as SEARCH_SUPPRESSED), amazonSku (the seller SKU Amazon knows the offer by when it differs from the CRM SKU, e.g. a variation child linked by its barcode), the ASIN and when it was checked, and markets (per Amazon store: stage, action, the price and quantity it shows); plus a count per stage over the whole channel. Worst first, 100 rows a page: total, limit, offset and hasMore say whether to read on with offset; stage filters (with marketplaceId, the stage and action are that store's). For a listing Amazon started by itself, stage no_offer on a store is a shell with no offer: publish_amazon_listings with that marketplaceId adds the offer to it (price, quantity and condition come from the product). With refresh=true it asks Amazon first (a read; writes only the CRM's record of the answer). It never changes an offer: send photos and GPSR contacts with preview_amazon_listing_content then update_amazon_listing_content; the rest is fixed in Seller Central or on the product. Use list_channel_products for price and stock on the channel and check_channel_readiness for products not yet listed.

Check up to 25 products against eBay before any write, with the same live preflight the CRM's eBay channel page and the real draft and publish calls run. Per product it returns the eBay state (off, member, draft, live, ended), nextAction (create_draft, publish_draft or none), whether that step is ready and, when not, the blocking reason with details. ebayDraftSetup lists the armed eBay sites and their currencies; remediation.ebayPlaybook maps every reason to the tool that fixes it; publishingEnabled says whether the owner allows AI to publish in this workspace. Reads eBay, never writes. Use search_products first for the ids; after a fix with update_product, upsert_product_prices, upsert_product_attributes or upsert_product_translation, call it again — a reason can change or clear.

Run every check saving a model's eBay multi-variation listing would run, writing nothing: each article's required fields and price in the marketplace currency, the variation axes (colour and/or size, named as the eBay site names them), duplicate or missing variation values, the category (suggested from the title, or the saved listing's), whether it allows variations, item condition, required item specifics, one shipping policy for all articles, business policies and inventory location. Returns ready, marketplaceId, categoryId, axes, variationCount and issues (reason, message, skus). Needs a marketplace but not the owner's arming. Reads eBay. Use save_ebay_variation_listing once ready is true.

List this workspace's activities (tasks, calls, meetings, emails, notes), filtered by type/assignee/overdue/completion/linked-entity and paginated. Returns summary rows (id, type, title, priority, dueDate, completed, assignee, linked lead/contact/company/deal, isOverdue) plus pagination { page, perPage, total }. Use get_activity to fetch one activity's full detail by id.

List the connected ad channels with their accounts: per channel the provider key, label, health (active, setup_required, error), the last sync time, any current sync error, campaign counts, and each account's id, name, currency, status and last sync. Also returns reportingCurrency, the workspace currency every revenue and ROAS figure is stated in. Read-only, from stored state: no ad platform is called, so a figure is as fresh as the last hourly sync. Takes no arguments. Use list_ad_campaigns with a provider for campaigns, spend and results, and list_ad_recommendations for what the CRM suggests.

List one ad channel's campaigns for the last N days, biggest spend first: status, objective, daily or lifetime budget, currency, spend and clicks (from the ad platform), and what the CRM recorded for the campaign — leads, deals, won deals, orders, sales, revenue, costPerLead. roas is revenue divided by spend, and is null — never guessed — when the ad account's currency differs from reportingCurrency, because that would invent an exchange rate; revenue is in reportingCurrency only. Read-only, from stored state, no ad platform is called. Use list_ad_accounts for the provider keys, list_ad_recommendations for what to do next, and get_report for the CRM's own sales reports.

List the CRM's open advertising recommendations across every channel: kind (spend_no_result, unanswered_leads, low_roas, scale_winner, cost_per_lead_spike), severity (urgent, warning, opportunity), the campaign and the frozen evidence the rule saw. They are deterministic rules over data only the CRM has — whether a click became a customer, what it paid, whether anyone replied — not a model's opinion. Snoozed and handled ones are not listed. Read-only; deciding a recommendation is done on the Ads page. Takes no arguments. Use list_ad_campaigns for the figures behind a card and list_conversations for the unanswered enquiries.

List the seller's Amazon shipping templates on ONE store — each template's id (the value Amazon takes) and name (as typed in Seller Central), read from Amazon's seller-specific product type schema through any category mapped to a product type. Templates exist per store (amazon.de has its own). When Amazon names none for this seller, templates is empty and note says so: templates are created in Seller Central only (no API creates or edits them), and until one is assigned Amazon applies the account's default shipping settings. Needs a category mapped to an Amazon product type (update_category) and a listing marketplace on the Amazon connection; no arming. Read-only: it changes nothing. Then assign one with set_amazon_shipping; use get_amazon_fields for the other product type fields.

List this workspace catalog brands with id, name, description and website. Use a brand id here as the brandId for create_product/update_product, or as the search_products brand filter.

List this workspace catalog categories as a flat array, each with id, name, slug, parentId (null for a root category), description, googleProductCategory, imageUrl, translations and marketplaceCategories (the Prom, Rozetka, OLX, Amazon and Google Merchant category ids already linked, each as { id, label } or null). Categories are workspace-global, not per warehouse. Use a category id here as the categoryId for create_product/update_product, or as the search_products category filter. Use get_category for one category's product and subcategory counts, and search_marketplace_categories to find a marketplace category id to link.

List how each connected sales channel prices products, one row per channel and currency: rule null means the base price, otherwise percent, fixed and rounding are added to it. The currency null means the channel has not told the CRM its currency yet. Read-only. Use preview_channel_price_rule to see what a change would do, and get_product_pricing for one product.

List the products that are on one marketplace, with each listing external id, what the marketplace last reported about it (`presence`, valid only when `observedAt` is set — null `observedAt` means the marketplace has never been asked about that listing, not that it is absent; Prom is reconciled every 15 minutes, other channels only when a sync or publish runs), whether the workspace paused syncing it, its price and stock. Also returns the honest totals over the whole channel and the ACTIVE products that have no listing there at all (the 'did not match by SKU' list), which is usually the answer when a push updated fewer products than expected. Pages by name: the first 40 by default, pagination { page, perPage, total, hasMore } says whether to read on (the totals and the unmatched list cover the whole channel on every page). Use check_channel_readiness for why a product would be refused and get_channel_sync_report for when each product was last sent.

List the social channels this workspace can publish posts to — Telegram channel, Instagram, Facebook page, LinkedIn, Threads, Viber channel — with, per channel, whether it is ready, where it posts (destination), its public address (profile: profileUrl, publicFeedUrl — a public Telegram channel reads without signing in at t.me/s/<name>, older posts via ?before=<post id> — and readableBy: anyone, login_required or not_public), its text limit (maxTextLength) and, when not ready, the setup step the person must do in Obriym. Open the profile with your own browsing to read every post the channel already has, including ones written outside Obriym. Also returns now (the current time on the workspace's clock) and the workspace time zone — build schedule_content_post times from them — the image rules, and publishingEnabled: whether the workspace owner allows AI clients to publish or schedule. Read-only. Call it before create_content_post and only target ready channels.

List the languages this workspace writes product content in: the base language (the text stored on products, categories and brands themselves), the extra languages the owner added, and the offered set — every language the CRM shows as a translation tab. Each entry is an ISO 639-1 code with its English name. Read-only. Call it BEFORE writing any translation (upsert_product_translation, upsert_category_translation, upsert_brand_translation) and write only offered languages; never write the base language as a translation.

List the workspace's social posts, newest first, 20 per page: id, working title, status (draft, scheduled, publishing, published, partial, failed), channels, scheduled and published times. Filter by status or by part of the title. Read-only. Use get_content_post for one post's texts and per-channel results; use it to check what is already scheduled before planning more posts.

List customer conversations across every connected channel (Instagram, Messenger, WhatsApp and comments, Telegram, OLX, Prom, eBay, Threads replies, the B2B portal, buyer order pages …). One row per lead and channel, newest first: { leadId, leadName, channel, lastMessageAt, lastMessageText (first 300 characters), lastDirection (inbound = from the customer), awaitingReply (the customer wrote last) } plus pagination { page, perPage, total }. Open conversations only — converted or disqualified leads and closed threads are left out. Filter by channel, by awaitingReply, or by a text match on the customer's name or last message. Read-only: replies are written by a person in the CRM Inbox, this server cannot send messages. Use get_lead_conversation to read one thread's messages and get_lead for the lead card.

List CRM customers: companies that bought — a purchase order (processing, ready to ship, shipped, delivered or refunded, or with a settled payment) or a won deal that never became an order. Filter by health, lifetime-value bucket, owner, name search or minimum won deals; sorted by lifetime value and paginated. Returns summary rows (id, name, health, lifetimeValue = completed-order revenue plus won deals without an order, purchases = purchase orders plus won deals without an order, repeat = two or more purchases, lastPurchaseAt, wonDealsCount = every won deal, lastActivityAt, owner) plus pagination { page, perPage, total }. Read-only. Use get_customer to fetch one customer's detail by company id; use list_people_customers for people who bought without a company (shop buyers).

List the eBay shipping (fulfillment) business policies the seller has on each eBay site the connection sells on: fulfillmentPolicyId, name, freeShipping, shippingCost of the first domestic service (null for CALCULATED shipping), costType, handlingTime, domestic and international services, ship-to regions, and isDefault — the connection default. productCount is how many products chose the policy themselves; staleAssignments are product choices pointing at a policy eBay no longer has. Reads the stored copy; a site never read before is read from eBay, and refresh true reads eBay now. Reads only. Use a fulfillmentPolicyId from here with set_product_ebay_fulfillment_policy, bulk_set_ebay_fulfillment_policy or set_ebay_default_fulfillment_policy; for one product's policy use get_product_ebay_fulfillment_policy.

List the workspace's GPSR companies — the manufacturers and EU responsible persons marketplaces ask for (Amazon takes them as the EMAIL of a record the seller created in Seller Central). Each has id, name, email, phone, website and address. Assign them to a brand or supplier with assign_economic_operators; a product takes each role from its brand, else its supplier. Read-only.

List this workspace's lead sources (built-in plus custom), with each source's key, label and active state. Pass includeInactive to also return archived sources. Use set_lead_sources to add or archive a source; use a source key here as the source filter for search_leads.

List every marketplace connected to this workspace with its setup state, health, last activity, any current sync error with `problem` (its kind, whether a person must reconnect the account, and what to do), `partialFailure` ({ failed, sent, sample, whatToDo }) when the last run reached the marketplace but part of it was refused (health stays active for that, so check it), orders revenue per currency, leads, product counts on the channel and how many imported products are waiting to be reviewed. advertising: true marks a channel where nothing is sold (Google Merchant), so its zero revenue is structural. Answers 'which channels do I sell on and is anything broken'. Takes no arguments. Use get_marketplace for one channel in detail, list_channel_products for what is on it, and check_channel_readiness for what it will refuse.

List this workspace's orders, filtered by status/customer/created-date and paginated. Returns summary rows (externalId, status, currency, totalAmount, itemCount, timestamps) plus pagination { page, perPage, total }, newest first. Use get_order to fetch one order's full detail (line items, payments, shipments, returns) by externalId.

List people (CRM contacts) who bought without a company — shop buyers: a purchase order without a company (processing, ready to ship, shipped, delivered or refunded, or with a settled payment) or a won deal of theirs without a company that never became an order. A company's purchases never count for the person who represents it. Filter by health, lifetime-value bucket, repeat (two or more purchases) or search over name, email and phone; sorted by lifetime value and paginated. Returns rows (id = contact id, firstName, lastName, email, phone, health, lifetimeValue, purchases, repeat, firstPurchaseAt, lastPurchaseAt, lastActivityAt) plus pagination { page, perPage, total }. Read-only. Use get_person_customer for one person by contact id; use list_customers for companies.

List this workspace's pipeline stages in order, with each stage's id, name, kind, default probability, WIP limit and position. Use configure_pipeline to change a stage, and the stage id here as the stageId for create_deal / transition_deal.

List what this workspace has already published to its social channels, newest first: per post the exact text each channel got (hashtags included), the channel, permalink, publishedAt, title, contentPostId and productId, plus per channel the publishing rhythm (lastPostedAt, postsLast7Days, postsLast30Days, medianGapHours, nextScheduledAt, scheduledCount) and, in sources, the channel's public address (profileUrl, publicFeedUrl) with a note. Only posts published through Obriym are listed. Posts typed directly into the network are not stored here — before planning, compare against BOTH this list and the channel itself: open sources[].publicFeedUrl or profileUrl with your own browsing to read everything posted there (a public Telegram channel reads at t.me/s/<name>; LinkedIn and Instagram may need a login; a Viber channel is read in the Viber app; a private channel cannot be read from outside). Never claim the channel had no other posts, and say so when a channel cannot be read. Use it before planning or writing new posts: avoid repeating a topic, product or phrasing, and use the rhythm to choose dates that keep a steady flow; then create_content_post and schedule_content_post. Filter by channel or by days (YYYY-MM-DD on the workspace's clock), 20 per page. Read-only. Use list_content_posts for drafts and scheduled posts, get_content_post for one post's per-channel results.

List the workspace's suppliers: id, name, status (active or archived), the currency they invoice in and how many products each covers (productCount). Read-only. Use it as the id source for a {kind:'supplier'} scope of preview_bulk_price_change and apply_bulk_price_change — 'raise every Sipec product by 5%'. Categories, brands and warehouses come from list_categories, list_brands and list_warehouses.

List this workspace warehouses with id, name, description, phone, address (the street line), country (ISO code), city, postalCode, workingHours (free text) and pickupEnabled (whether the warehouse is offered as a self-pickup point). A product lives in at most one warehouse, and the warehouse decides the inventory-tracking default and which sales channels new products are listed on. Use a warehouse id here as the warehouseId for create_product.

List every workspace the connected user belongs to (id, name, role) and mark which one this connection currently operates. OAuth sign-in connections only. Use select_workspace to switch.

Ask Amazon whether it would take the photos, GPSR contacts, texts, safety documents, shipping settings and missing listing data of up to 25 products on their EXISTING Amazon offers — Amazon's own dry run (VALIDATION_PREVIEW), which changes nothing. Per product: status (ready = Amazon would accept; nothing = nothing to send, see skipped; blocked = no offer to write to, see reason: noListing, removedFromChannel, syncPaused, listingNotFound, variationParent; rejected = Amazon refused it, see issues in the marketplace's language; failed = the call failed), the attributes it would send, filled (what the attributes part fills, by key and the store's own title), stillMissing (what this store's product type requires and nobody has answered: set it with set_amazon_field_values, keys and values from get_amazon_fields), untranslated (what the store lacks and the CRM knows only in another language: write it with upsert_product_translation, or set_channel_texts for the title and points) and skipped (noImages, noManufacturer, noResponsiblePerson, noTexts, noDocuments, noShipping; noAttributes = this store already shows everything the CRM could fill; colorFamilyUnknown = the colour's name goes, but which of Amazon's colour families it is cannot be told from it: set color.standardized_values on the product with set_amazon_field_values; the product type does not take that attribute: textsNotInSchema, documentsNotInSchema, templateNotInSchema, handlingNotInSchema; templateNotInStore = the template is not one of this store's; shippingNotMfn = Amazon ships the offer itself; handlingNoQuantity = no tracked stock to carry the handling time). GPSR companies are set on the brand or supplier (assign_economic_operators), Amazon texts with set_amazon_listing_texts, safety documents with set_product_safety_documents, shipping with set_amazon_shipping. Needs a listing marketplace chosen on the Amazon connection; no arming. Then send with update_amazon_listing_content. Use inspect_amazon_listings first to find offers Amazon flags.

Dry run of a bulk price change — step 1 of 2; nothing is written. Give a rule (percent, fixed, fromCost, discount, endDiscount, compareAtMarkup, compareAtClear), a scope (a named category, brand, supplier, warehouse or model, or up to 100 explicit product ids) and optionally a target (the product's price, a price-list currency, or the purchase cost). Returns totalItems (how many products would change), a sample of up to 10 with from/to, old price and cost, belowCost (how many would sell below their cost), skipped grouped by reason (no price, no cost, no rate, unchanged, …), the currency, and a digest. Always show the person the counts, the sample, the skipped reasons and any belowCost warning BEFORE applying. Then call apply_bulk_price_change with the SAME rule, scope and target and this digest. Ids come from list_categories, list_brands, list_suppliers, list_warehouses (a category includes its sub-categories only with includeSubcategories) and search_products. Read-only and repeatable.

Dry run of a price rule for one sales channel in one currency, step 1 of 2; nothing is written. A rule prices every product on the channel from its base price (price + percent, then + fixed, then rounding) and moves with the base price; a product with its own price on the channel keeps that price. Pass rule null to go back to the base price. Returns how many products would change, how many have their own price, how many have no price in that currency, how many would sell below cost, sample rows before and after, and the digest set_channel_price_rule needs. Show the person this result before saving. Advertising channels (Google Merchant) cannot have a rule.

Show, for 1 to 25 products, the exact body the Google Merchant push would send for each one — title, description, link, image links, price, availability, identifiers and custom labels — or the reason it would be held back (blocker: no_url, no_title, no_price, no_image, no_translation, not_shoppable, no_feed_label). It walks the same collect step and the same builder as the real push, so it cannot differ from what Google would receive. Local and read-only: no Google call, nothing is sent or stored, and it needs no arming. A product that is not an active, unpaused member of the Google channel is listed in notOnChannel (set_channel_membership adds it). Returns { adapterId, adapterName, feedLabel, currency, contentLanguage, items, notOnChannel }. Use check_channel_readiness for the whole channel's blockers and push_google_merchant_catalog to actually send; fix a blocker with update_product, upsert_product_prices or upsert_product_translation and preview again.

Dry run of a Google Shopping campaign, step 1 of 2: the very request create_google_shopping_campaign would send, validated by Google with validateOnly — nothing is created in the ad account. Returns { currency, payload } or Google's own refusal (a duplicate name above all). It does record that a dry run happened, which is the evidence the owner needs before arming campaign creation on the Ads page; it arms nothing and needs no owner switch. Needs a signed-in connection with the ads:write scope and a role that works with ads; an API token is refused because it carries no role. Show the person the payload before creating. Idempotent. Use list_ad_accounts for the account and currency, and create_google_shopping_campaign for step 2.

Create Amazon listings for up to 25 products — a REAL publication on the seller's Amazon account. Each product runs the full check again (Amazon's dry run included) and is refused with Amazon's own sentences if anything changed; a product whose barcode Amazon already knows becomes an offer on that existing item. Run check_amazon_readiness first and pass only ready products. Refused until the owner switches on AI publishing, and while listing creation is not armed on the Amazon connection. Returns created (with the ASIN or SKU and, in submitted, the price, currency, quantity and fulfilment the listing was sent with — quantityOmitted says why no quantity went out: stockNotTracked or stockUnknown; an FBA offer's quantity is Amazon's own), failed (reason, details) and notAttemptedIds. created means Amazon ACCEPTED the submission for processing, not that the listing is live or buyable: Amazon finishes it asynchronously, so check the outcome later with inspect_amazon_listings and never tell the user a listing is live from this result alone. Not idempotent: a product already listed fails with alreadyListed. The result echoes the workspace.

The model's active articles not yet on Amazon become ONE listing with variations — Amazon's "variation family"; call it a model with variations when talking to the user: a parent whose SKU is the model's code (no price, no quantity) and a child listing per article, varying by colour and/or size — the theme is chosen from what the Amazon product type declares. Every listing is first validated by Amazon (VALIDATION_PREVIEW); only when ALL of them would be accepted is the family created — a REAL publication: the parent first, then each child with its price and quantity. Run check_amazon_variation_family first. Refused until the owner switches on AI publishing, and while listing creation is not armed on the Amazon connection. Returns the same report with statuses created, failed, notAttempted or notChecked; each child's offer names the price, currency, quantity and fulfilment it is submitted with (quantityOmitted says why no quantity goes out), and progress says what is left (createdNow, alreadyOnAmazon, remaining, notReached) and the one next step: done, callAgain, fixAndRetry, fixGaps or publish. A model of about 80 articles is meant to finish in one call; a bigger one, or a slow Amazon, takes more: notChecked and notAttempted both mean the run ran out of time, so call again — a dry run an article passed is kept for an hour while its data stays the same, created articles are skipped (nothing is submitted twice), the parent and the theme stay, and the rest continue. created means Amazon ACCEPTED the child for processing, not that it is live: Amazon finishes asynchronously, so check the outcome with inspect_amazon_listings and never tell the user the family is live from this result alone. The result echoes the workspace.

Publish a post NOW to every ready channel of it — a real, public post in the business's name that followers see at once and that cannot be taken back from Obriym. A channel already published is never sent twice, so calling it again only retries the channels that failed or were not ready. Returns, per channel, the outcome (published, failed, already_published, skipped_not_configured with the setup step, skipped_empty, skipped_unsupported), the link to the live post and the network's error. Needs the owner's "AI may publish to social channels" switch (publishingEnabled in list_content_channels). Confirm with the person before calling it unless they asked for the publication outright. Echoes the workspace.

Make the eBay DRAFT offers of up to 25 products LIVE and buyer-visible — a real publication on the seller's account. The item and offer are refreshed from the current product first, so a price, title, photo or characteristic fixed after the draft was made is published too. Pass only products whose nextAction from inspect_ebay_listings is publish_draft. Returns done, failed (with reasons) and notAttempted. Never tell the user a listing is live unless it is counted in done. Refused until the owner switches on AI publishing. The result echoes the workspace.

Publish a product model on eBay as ONE live listing with variations: saves it first exactly like save_ebay_variation_listing (so eBay gets the articles as they are now), then publishes the whole group — a real listing buyers can purchase. Returns status: blocked (with issues — reason, message, skus — and nothing written), saved (a draft on eBay) or published, plus marketplaceId, listingId, listingUrl, publishedAt, variationCount, failed (variations eBay refused, by sku — nothing is published while any) and removedSkus (articles that left the listing). A partial/uncertain publication returns reason ebayVariationReconciliationPending with retryable=true. Retry the same operation to check eBay first; never withdraw or delete to repair it. Confirmed recovery updates CRM links without publishing again. Needs listing creation armed on the eBay connection, and is refused until the workspace owner switches on AI publishing. Confirm with the user before calling. The result echoes the workspace.

Send this workspace's catalog, or just the products you name, to Google Merchant Center now — the same as the "Update now" button on the Google Merchant channel page. It is a REAL write to Google: products become or stay visible in Google Shopping. It runs only the product push the owner has ALREADY armed on the connection (otherwise it is refused) and only after the owner accepted Google's terms; it never arms anything and never changes settings. Refused until the owner switches on AI publishing. It is rarely needed: an hourly job sends the catalog anyway, so use it only when a fix must reach Google before the next run. To get one fixed product to Google immediately pass productIds (1 to 25): only those products are sent, and the result is { adapterId, adapterName, sent, failed, blocked, notOnChannel } — sent and failed (with Google's own message) name each product, blocked carries the readiness reason, notOnChannel lists ids that are not active channel members; this does not change the channel's last-run summary. Without productIds the whole catalog is sent, never-sent and changed products first, bounded by a time budget — if truncated is true, call it again. Returns { adapterId, adapterName, outcome } where outcome has pushed, failed, blocked, ready, total, truncated, lastSyncAt and failedSample (up to 5 refused products with Google's message). A failure that came back from Google carries reason (for example auth_expired) with details.needsReconnect and details.whatToDo: auth_expired, such as invalid_grant, means a person must reconnect the Google account on the adapter page, and retrying will not help. Use check_channel_readiness first to see which products would be withheld, and get_marketplace for the last run. Not idempotent. The result echoes the workspace.