Segmind

Check on a submitted job and, once finished, return its output. Looks up the ``request_id`` returned by ``submit_inference`` (or by a ``run_inference`` call that reported ``pending``). If the job has completed, output images are shown inline and the full result is in the structured content — exactly as ``run_inference`` returns. If it is still queued or processing, the result has ``pending: true``; wait a few seconds and call again. A failed job raises with the model's error. Results are kept for about an hour after completion.

Check a submitted Pixelflow run and, once finished, return its outputs. Outputs come back keyed by the flow's output ``keyname`` — usually a hosted ``https://images.segmind.com/outputs/...`` URL that can be fed straight into another model or flow. While the run is queued or processing the result has ``pending: true``; wait ~15s and call again. A failed flow raises with the failing node's error, which names the node id. The spec does not map node ids back to models, so report the id together with the chain from ``get_pixelflow_spec``'s ``models`` rather than claiming to know which one broke. An error like ``image not found`` or a bare status code from a node whose inputs are correct means some node's model is broken, not that the input was wrong — report it rather than retrying.

Compare a shortlist of models side by side, including their price tables. Call this whenever the user asks which model is cheapest, what a model costs, or how models' prices compare: ``list_models`` only reports observed spend, and this tool is the only way to get list prices without reading whole specs. Shortlist with ``list_models`` first (e.g. ``sort="cost"``), then pass its top slugs here. For each slug returns the same row as ``list_models`` (observed average cost, latency, popularity, partner, price drivers) plus ``pricing``: the model's base price as markdown from its spec — a flat per-run price, a table keyed by the parameters that change it (e.g. duration by resolution), a per-GPU-second rate, or per-token rates. Quote prices from ``pricing``, not from ``average_cost``. Every row has the same keys. ``error`` is ``null`` unless that slug's spec could not be fetched (unknown slug, upstream failure), in which case ``pricing`` is ``null`` too. ``pricing`` is also ``null`` when the spec has no pricing section (some embedding models); read ``get_model_spec`` then. The summary fields are ``null`` for a slug the public catalog does not list.

Get a URL to upload a local file to, when you can read the file yourself. Use this whenever the user names a file by path and you can measure it — it is the whole upload flow for any host that does not hand attachments to tools, which is every host except ChatGPT. You need no Segmind credential: the returned ``upload_url`` carries its own, for about half an hour. Three calls end to end:: create_upload_ticket("cat.png", 489626) curl -sf -X PUT --data-binary @cat.png <required headers> "<upload_url>" run_inference(slug=..., params={"image": "<url_after_upload>"}) The result is ``status: awaiting_upload`` and carries **no** ``url``, because nothing is hosted until that PUT succeeds. ``url_after_upload`` is the model input, and only afterwards — passing it early submits a run that cannot work. Send every header in ``required_headers`` verbatim or the PUT fails with ``SignatureDoesNotMatch``. If you cannot run the PUT yourself, give the exact command to the user and wait for them to confirm it succeeded.

Get the authenticated user's Segmind credit balance. Returns the paid ``credits`` balance and the ``free_credits`` (free / promotional) balance. Use this to check whether the account has enough credit before running a paid generation.

Get a Segmind model's full spec as LLM-readable markdown. Fetches ``https://www.segmind.com/models/{slug}/llms.txt`` and returns the markdown unchanged. The spec documents the model's endpoint, pricing, input/output schema, and usage examples — read it to learn exactly how to call a model (e.g. before running an inference). Specs are cached briefly per slug within a session. To compare several models' prices, prefer ``compare_models``, which returns only the pricing section of each spec.

Get a Pixelflow's runnable spec: its inputs, outputs, and the models it chains. Call this before ``submit_pixelflow`` — a flow's input keys are arbitrary names chosen when it was built (e.g. ``video_in``, ``image_kj3ba``), so they cannot be guessed. Each input reports the ``keyname`` to send it under, the ``kind`` of value it wants (``video``, ``image``, ``str``, ``num``), and, where the flow was saved with one, an ``example`` value. ``models`` lists every model slug the graph runs, in order — pass them to ``compare_models`` to price the run before spending.

Browse and rank the live Segmind model catalog to choose a model. Returns a page of ranked models under ``models``, one row per model with its ``slug``, ``name``, ``category``, ``description``, ``average_cost``, ``latency`` (observed seconds per run), ``popularity`` (usage score), ``partner`` (provider) and lifecycle flags, plus catalog-wide totals and a per-category breakdown that do not depend on the page. When asked how many models exist, overall or per modality, answer from those totals; never count or estimate from the returned page, which is capped at ``limit``. ``average_cost`` is NOT a price. It is the average USD that past runs of the model actually cost, which depends on the inputs those users chose (the parameters in ``price_drivers``) and on how few runs there have been. Use it only to rank and shortlist. To say which model is cheapest, or to quote or compare prices, always follow up with ``compare_models`` on the top slugs; it returns each model's base price table from its spec. Pass a ``slug`` to ``get_model_spec`` to learn how to call the model you pick. Filters are optional and combine (AND). Deprecated and coming-soon models are hidden unless ``include_unavailable`` is set. Results are sorted by ``sort`` (most popular first by default), so when ``truncated`` is true, raising ``limit`` only reveals lower-ranked models.

Browse Segmind's published Pixelflows — saved multi-model workflows. Each row carries the ``slug`` to pass to ``get_pixelflow_spec`` / ``submit_pixelflow``, what the flow does, and the models it chains. Rows carry no price: a flow bills **every** model in its chain, so cost one by calling ``compare_models`` over the ``models`` that ``get_pixelflow_spec`` reports and adding them up. Use a Pixelflow when the user's job is a known pipeline someone already assembled; use ``run_inference`` when a single model does the job.

Health-check tool. Returns ``pong`` and the running server version.