Server definition

Hash: sha256:0067ce0f1157b840e3010de00a3d062e2bd506ad2c2345ac0fa85f499c674a96
What it is: What a remote MCP server returned when asked what it offers: 29 tools

The blob, as servednamed by its sha256

{
  "instructions": "Valet hosts software an organization builds for itself: websites, Procfile apps, and agents, each served at its own URL. These tools create, publish, read back, and update them, and read the organization's standards for doing so.\n\nBefore any work, call get_skill with governance and follow it. It says what the organization expects, in what order to work, and which other skills to read and when. Read it again before any publish call. An organization may have replaced it; the result says whether you are holding the organization's version or Valet's default.\n\nReach for publish_site whenever an answer reads better at a live URL than as text in the conversation: a report, essay, slide-like narrative, dashboard, marketing surface, or other static artifact. Reach for publish_app when the work needs a server process and a Procfile says how to run it. Every publish names the thing: title and description are required on sites and apps, and a call missing either is refused before anything is published.\n\nDiscover before deciding. list_services says what the organization already has; get_source reads what was published so you change it rather than replace it. list_skills says what the organization has written down. list_attachable_connectors, list_catalog_connectors, and create_connector are the path from a personal integration to an organization connector a page or app can use.\n\nPublishing uses a connected Valet account by default. Pass anonymous: true only when the user explicitly wants a temporary public site. An anonymous site is public to anyone who has the link and may be removed 36 hours after it is created, unless it is claimed; the result carries a claim URL that makes it permanent.\n\nPass an idempotency_key on every publish, follow a build with get_build, and verify the published URL before reporting success. When you cannot fetch it, confirm with get_build and get_service instead and tell the user you could not load the page.",
  "tools": [
    {
      "description": "Attach an organization connector to a website, app, or agent so it can call the connector's tools with the credential Valet holds. It is attach_site_connector for every kind.\n\nAttaching is a grant, and it is wider than it looks: for a website, every person who can open the page can call every tool; for an agent, the agent can. Attach only what the thing needs. A website can hold only an HTTP MCP server, which list_attachable_connectors reports; an app cannot hold a connector yet and the call says so. Attaching a connector that is already attached changes nothing and is safe to repeat. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "connector": {
            "description": "Required. The organization connector's name, which is also the name it is called by.",
            "type": "string"
          },
          "name": {
            "description": "Required. The website's, app's, or agent's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization both belong to. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "connector"
        ],
        "type": "object"
      },
      "name": "attach_connector",
      "outputSchema": null
    },
    {
      "description": "Attach a resource to an app: a named set of environment variables, such as a database's connection string, that the app reads as secrets. Name the resource. When the organization has none by that name, pass a provider from list_resource_catalog and the first call creates it, returning at once with state provisioning. Call again with the same arguments, env_prefix included, until the state is attached: the call that finds the resource ready attaches it and sets its variables, restarting the app if it is running. An existing resource attaches by name alone, including one another app holds. The call is safe to repeat: one name is one resource however many times it is called, and an app can hold several under different names. Pass env_prefix when two resources would set the same variables. Read the names an attachment sets from list_resource_catalog before writing the app's code. A new database is empty, so the app creates its own tables, and its URL carries the TLS settings it needs. The app must exist, so publish it first. After the attach restarts it, get_service shows whether it is running again. Provisioning takes about a minute; call again every ten seconds. Values are never returned here. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "env_prefix": {
            "description": "Set the resource's variables under PREFIX_NAME rather than NAME: an uppercase letter, then up to 31 uppercase letters, digits, and underscores. Omit to use the names as they are. Repeat it on every call for one resource: it applies on the call that attaches.",
            "pattern": "^[A-Z][A-Z0-9_]{0,31}$",
            "type": "string"
          },
          "name": {
            "description": "Required. The app's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the app belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "plan": {
            "description": "The provider's plan. Omit to use its first plan. Repeat it on every call for one resource.",
            "type": "string"
          },
          "provider": {
            "description": "The provider to create the resource from, from list_resource_catalog. Required when the organization has no resource by this name.",
            "type": "string"
          },
          "resource": {
            "description": "Required. The resource's name in the organization, such as shop-db: 3 to 63 lowercase letters, digits, and hyphens. Repeat it on every call for one resource.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "resource"
        ],
        "type": "object"
      },
      "name": "attach_resource",
      "outputSchema": null
    },
    {
      "description": "Attach an organization connector to a website so pages served from that site can call the connector's tools.\n\nAttaching is a grant, and it is wider than it looks: every person who can open the page can call every tool the connector exposes, using the credential Valet holds for it. On a private site that is every member of the organization; on a password-protected or shared one it is everyone holding the password or the link. Valet does not narrow the connector's reach for a page, so attach only what the page needs and check the site's access mode before you do.\n\nOnly an organization connector that is an HTTP MCP server — transport sse or streamable-http — can be attached; list_attachable_connectors reports exactly that set. A connector that belongs to a single agent cannot back a page. A page calls the connector by its own name, which is what list_site_connectors reports and what the page's request path carries. Attaching a connector that is already attached changes nothing and is safe to repeat. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "connector": {
            "description": "Required. The organization connector's name. It is also the name a page served from the site calls it by.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the site and the connector belong to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site": {
            "description": "Required. The site's name.",
            "type": "string"
          }
        },
        "required": [
          "site",
          "connector"
        ],
        "type": "object"
      },
      "name": "attach_site_connector",
      "outputSchema": null
    },
    {
      "description": "Run one tool on a connector attached to a website and return what the connector answered. It is the sampling step of building a page that calls live data: discover, attach, read the schemas, then call one tool for real before you write any page code.\n\nCall it because a schema is not a shape. list_site_connectors gives you each tool's name and argument schema, which is what your call has to satisfy; this tells you what comes back, which is what the page has to parse. Results are text to read, not JSON to assume: many servers answer in markdown tables or prose, some expose a single meta-tool taking a whole command as one string, and a server that completes the handshake can still refuse half its tools when the stored credential's scope does not cover them. One real call settles all three.\n\nThis runs the tool for real, with the organization's own credential and whatever side effects the tool has. It is not a dry run and there is no preview: a tool that sends, writes, or deletes will do so. Prefer a read-only tool when you are only learning the shape, and ask the user before running anything that changes their systems.\n\nThe connector must already be attached to the site — attach_site_connector does that — and must be an HTTP MCP server. A tool that answers with an error is reported as an error carrying the connector's own text, which is usually the sentence that says what to fix. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "args": {
            "description": "Arguments for the tool, as an object matching the tool's own input schema from list_site_connectors. Omit it for a tool that takes none.",
            "type": "object"
          },
          "connector": {
            "description": "Required. The name the connector is attached under, which is the name a page calls it by.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the site belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site": {
            "description": "Required. The site's name.",
            "type": "string"
          },
          "tool": {
            "description": "Required. The tool to run, spelled exactly as list_site_connectors reports it.",
            "type": "string"
          }
        },
        "required": [
          "site",
          "connector",
          "tool"
        ],
        "type": "object"
      },
      "name": "call_site_connector",
      "outputSchema": null
    },
    {
      "description": "Create an organization connector from a Valet catalog entry. It is the step after list_catalog_connectors found the entry for the product the user named; attach_site_connector then lets a website's pages call it.\n\nIt creates an entry whose credential is a secret. Pass each slot the entry asks for in secrets, as slot name to value. A slot the organization already holds as a secret needs no value here. If a required slot has neither, nothing is created and the answer names the slots still needed.\n\nA key given here passes through this conversation. That is a real cost and it is the user's call to make: if they hand you the key, use it, and say that they could instead enter it on the dashboard's Integrations page, where it goes straight to Valet. The answer names the slots that were filled and never the values in them.\n\nAn entry that authorizes in a browser — OAuth, or a Composio toolkit — is not created here. The answer gives the entry's name and the Integrations page, which creates the connector and runs the authorization in one place. An entry the organization already has is reported as already there; no second connector is made. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "entry": {
            "description": "Required. The catalog entry's name, spelled exactly as list_catalog_connectors reports it.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization to create the connector in. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "secrets": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "The entry's secret slots, as slot name to value. Valet stores each as an organization secret. A value passed here travels through this conversation; leave it out and point the user at the dashboard's Integrations page when they would rather it did not. A slot the organization already holds needs no value.",
            "type": "object"
          }
        },
        "required": [
          "entry"
        ],
        "type": "object"
      },
      "name": "create_connector",
      "outputSchema": null
    },
    {
      "description": "Delete a resource and all of its data, such as every table and row in a database. This cannot be undone, so confirm with the user first. A resource attached to any app is refused, and the answer names those apps: detach it from each with detach_resource, then delete it. The provider removes it in the background. Deleting a resource that is already being deleted changes nothing. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization the resource belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "resource": {
            "description": "Required. The resource's name in the organization.",
            "type": "string"
          }
        },
        "required": [
          "resource"
        ],
        "type": "object"
      },
      "name": "delete_resource",
      "outputSchema": null
    },
    {
      "description": "Permanently delete a website or app and stop serving it. This cannot be undone, so confirm with the user first. Pass kind to say which you mean; a name holding another kind is then refused rather than deleted. Deleting an app stops it and removes its releases and source; its resources are detached and kept, because they belong to the organization and may serve other apps, and the answer names them for delete_resource. Identify the service by name, which requires connecting a Valet account, or a website published anonymously by the site_token returned when it was published — whoever published a site can always take it down. Agents are deleted with the Valet CLI.",
      "inputSchema": {
        "anyOf": [
          {
            "required": [
              "name"
            ]
          },
          {
            "required": [
              "site_token"
            ]
          }
        ],
        "properties": {
          "kind": {
            "description": "The kind you mean. Omit to delete whatever the name holds; give it to have a name holding another kind refused.",
            "enum": [
              "site",
              "app"
            ],
            "type": "string"
          },
          "name": {
            "description": "Give this or site_token. The website's or app's name, which requires a connected Valet account.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization it belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site_token": {
            "description": "Give this or name. The token returned when a website was published anonymously; it identifies that one site.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "delete_service",
      "outputSchema": null
    },
    {
      "description": "Detach a connector from a website, app, or agent, ending the grant attach_connector made. The connector itself stays in the organization. A page or agent that still calls it starts getting an error, which is the intended outcome. Detaching a connector that is not attached leaves the same absence. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "connector": {
            "description": "Required. The name the connector is attached under.",
            "type": "string"
          },
          "name": {
            "description": "Required. The website's, app's, or agent's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization both belong to. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "connector"
        ],
        "type": "object"
      },
      "name": "detach_connector",
      "outputSchema": null
    },
    {
      "description": "Detach a resource from an app: remove the environment variables it set and restart the app if it is running, so a running app loses them at once. The resource itself and its data are unchanged, and other apps that hold it keep it. Detaching a resource that is not attached changes nothing. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "name": {
            "description": "Required. The app's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the app belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "resource": {
            "description": "Required. The resource's name in the organization.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "resource"
        ],
        "type": "object"
      },
      "name": "detach_resource",
      "outputSchema": null
    },
    {
      "description": "Detach a connector from a website, so pages served from that site can no longer call it. The connector itself is left in place for the rest of the organization, and nothing else about the site changes.\n\nThis is how the grant attaching made is taken back. While a connector is attached, everyone who can open the page can call every tool it exposes with the credential Valet holds, so detaching is the way to end that reach. A page that still calls the connector starts getting an error, which is the intended outcome. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "connector": {
            "description": "Required. The name the connector is attached under, which is the name a page calls it by.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the site belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site": {
            "description": "Required. The site's name.",
            "type": "string"
          }
        },
        "required": [
          "site",
          "connector"
        ],
        "type": "object"
      },
      "name": "detach_site_connector",
      "outputSchema": null
    },
    {
      "description": "Follow a build publish_app started: its state, the log it has written so far, and, once it succeeds, the release it produced and the URL that now serves it. Poll every ten to fifteen seconds until the state is terminal; most builds finish within five minutes. A failed build's log is where the reason is, usually a missing dependency or a start command that exited. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "build_id": {
            "description": "Required. The id publish_app returned.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the build belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "required": [
          "build_id"
        ],
        "type": "object"
      },
      "name": "get_build",
      "outputSchema": null
    },
    {
      "description": "Get how a page served from a Valet site talks to the connectors attached to it. It is the pair to get_skill with design-system: consult that for the artifact's identity, this one for how it talks to its connectors. Call it before writing any page code that fetches from a connector.\n\nReturns the same-origin request contract and a paste-whole session helper that handles both sessionless and stateful connectors, plus the rules a page has to follow: handling a 403, recovering a lapsed session, and never caching a response on the caller's behalf.\n\nThis needs no Valet account. It answers with static guidance about how pages work — nothing here reads an organization or a site — so an agent can call it before running any OAuth flow.",
      "inputSchema": {
        "properties": {},
        "type": "object"
      },
      "name": "get_connector_client",
      "outputSchema": null
    },
    {
      "description": "Get one website, app, or agent by name. The result carries the fields every kind has, then a section for its kind. A website: access mode, the people it is shared with, and attached connectors. An app: each process type with its scale and current state, attached resources with their state, environment variable names, and the active release. An agent: channels, connectors, declared skills, and blueprint state. Every kind: whether a draft is open and who opened it. Fields another kind would have are absent.\n\nA shared website lists each recipient's email, as the dashboard does. A password-protected website reports that it is gated and never its visitor password. An app reports access as public and that no other mode exists. Identify it by name, which requires connecting a Valet account, or, for a website published anonymously, by the site_token that publish returned.",
      "inputSchema": {
        "anyOf": [
          {
            "required": [
              "name"
            ]
          },
          {
            "required": [
              "site_token"
            ]
          }
        ],
        "properties": {
          "name": {
            "description": "Give this or site_token. The service's name, which requires a connected Valet account.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization it belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site_token": {
            "description": "Give this or name. The token returned when the site was published anonymously; it identifies that one site.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "get_service",
      "outputSchema": null
    },
    {
      "description": "Get one skill by name: the organization's own when it has published one under that name, otherwise the default Valet supplies for a well-known name. Call it with governance before any work and again before any publish; that skill says what the organization expects and names the other skills to read. Call it with any name list_skills reports, or any name the governance skill tells you to read.\n\nThe result says where the skill came from. source: org is the organization's own content and overrides anything Valet would have said. source: default is Valet's, returned because the organization has not written its own; for design-system it is the preset the organization selected, and reason says why a selection could not be honored when one could not. Supporting files are listed by path and read with get_skill_file.\n\nBy default this requires a connected account. Pass anonymous: true only when building an explicitly anonymous site; no organization is then consulted, and only a well-known name has an answer.",
      "inputSchema": {
        "properties": {
          "anonymous": {
            "description": "Set true only when building an explicitly anonymous site. No organization is consulted and Valet's default is returned. Omit for the account-first path.",
            "type": "boolean"
          },
          "name": {
            "description": "Required. The skill's name: governance, design-system, or any name list_skills reports.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization whose skill to read. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "type": "object"
      },
      "name": "get_skill",
      "outputSchema": null
    },
    {
      "description": "Read one supporting file of a skill, by the path get_skill listed. A skill's SKILL.md points at its files for the detail it does not inline: a checklist, a template, a schema, an example. Read the ones the skill tells you to; do not read every file on principle. Binary files are listed but not returned here. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization whose skill to read. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "path": {
            "description": "Required. The file's path within the skill, as get_skill listed it.",
            "type": "string"
          },
          "skill": {
            "description": "Required. The skill's name, as given to get_skill.",
            "type": "string"
          }
        },
        "required": [
          "skill",
          "path"
        ],
        "type": "object"
      },
      "name": "get_skill_file",
      "outputSchema": null
    },
    {
      "description": "Read what is published: the files of a website, app, or agent's active release. Without path it lists them; with path it returns one file's text. Read before you change something someone else built, so your publish carries their work forward rather than replacing it with yours. Binary files are listed and not returned. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "name": {
            "description": "Required. The service's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization it belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "path": {
            "description": "A file to read. Omit to list the files.",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "type": "object"
      },
      "name": "get_source",
      "outputSchema": null
    },
    {
      "description": "List the organization connectors a website can hold — the discovery step before attach_site_connector.\n\nOnly connectors a page can actually call appear: HTTP MCP servers reached over the sse or streamable-http transport. Command connectors and stdio MCP servers are excluded by definition — they run inside an agent's container and no page can reach them — so a connector the organization has that is not listed here cannot back a site.\n\nPass site to mark which connectors that site already holds; attached connectors stay listed because attaching is idempotent. Tool schemas are not included — attach the connector, then list_site_connectors reports its live tools and their schemas, which is the moment to write the page's calls. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization whose connectors to list. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site": {
            "description": "A site to mark already-attached connectors against. Omit for the plain organization-wide list.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "list_attachable_connectors",
      "outputSchema": null
    },
    {
      "description": "List the connectors Valet curates — the catalog an organization creates a connector from. Reach for it when list_attachable_connectors returned nothing that serves the data a page needs: the organization has no connector for it yet, and this says whether Valet has an entry for the product and what setting it up would take.\n\nEach entry says how its credential arrives. An entry that takes a secret names each slot it asks for and what the slot is. An entry that authorizes in a browser, or connects through Composio, says so — a person completes those on the dashboard's Integrations page, and no answer here can stand in for that.\n\nEach entry also says whether a website's pages could call it. That is a marker, not a filter: an entry only an agent's container can run is still listed, because \"Valet has your product, but no page can call it\" is a real answer and reporting it as missing is not. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization a connector would be created in. The catalog is the same for every organization; this names the one the answer points the next step at. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "list_catalog_connectors",
      "outputSchema": null
    },
    {
      "description": "List the resource providers this server can provision from, such as a PostgreSQL database: each one's plans, the first being the default, and the environment variables an attachment sets. Read it before attach_resource creates a resource. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization to list for. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "list_resource_catalog",
      "outputSchema": null
    },
    {
      "description": "List what the organization has published: every website, app, and agent, with its kind, URL, access mode, and when it was last published. It is the first read when the user names something and you do not know what it is, and the way to recover a name an earlier publish has scrolled out of the conversation. Pass kind to narrow to one kind. Apps are always public; the row says so. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "kind": {
            "description": "Narrow the list to one kind. Omit for everything.",
            "enum": [
              "site",
              "app",
              "agent"
            ],
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization to list. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "list_services",
      "outputSchema": null
    },
    {
      "description": "List the connectors attached to a website, each with the tools a page served from that site can call. Read it before writing a page that calls one: the tool names and argument schemas it returns are what the page's own calls have to match, and guessing them produces a page that fails on its first click.\n\nIt lists what is attached to this one site, not what the organization has available. A connector nobody attached to this site does not appear here, and attaching one is a separate, deliberate act — it hands the connector's reach to everyone who can open the page.\n\nEach connector says whether a page can call it, and whether the server keeps an MCP session the page must hold — the page runs the initialize handshake, replays the Mcp-Session-Id header, and re-initializes when the session lapses. The broker forwards the handshake and the tool calls, and always hands the page one JSON document per request, whatever framing the server chose. A connector that could not be reached reports its own error and leaves every other row intact, so one expired credential does not hide the rest. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization the site belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site": {
            "description": "Required. The site's name.",
            "type": "string"
          }
        },
        "required": [
          "site"
        ],
        "type": "object"
      },
      "name": "list_site_connectors",
      "outputSchema": null
    },
    {
      "description": "List every skill the organization has: the well-known names with whichever source currently answers for each, then every skill the organization wrote or installed from the catalog. Each row carries the skill's description, which is the sentence saying when it applies. The governance skill tells you to call this and read every skill whose description applies to the work at hand; this is how an organization's own standards reach you without anyone naming them. Names and descriptions only; get_skill reads content. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "org_name": {
            "description": "The Valet organization to list. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "list_skills",
      "outputSchema": null
    },
    {
      "description": "Publish source as an app: a process Valet builds from your files and runs behind a public URL. Use it when the work needs a server, a background process, or a database. A Procfile at the root says how to start each process type; the web type serves the app's URL and must listen on $PORT, which Valet sets. Node, Python, and Go are supported. Apply the governance skill before calling.\n\ntitle and description are required and a call missing either is refused: Valet writes the app's valet.yaml from them, and any valet.yaml in files is replaced. Content is text: source files, lockfiles, Procfile, configuration. Images and other binary assets are not supported on this surface. Dependencies are installed during the build from the manifest you publish: package.json, with its lockfile when you have one; requirements.txt; or go.mod, where go.sum is optional and the build completes it. Do not include installed packages.\n\nPublishing to a name that exists replaces its source with these files, so read get_source first when the app is not yours. The publish returns a build id; the app is live only when get_build reports it is, and the first deploy can take a few minutes. The first publish creates the app, so set environment variables and attach resources after it: set_env_vars and attach_resource each restart the app with its new variables. Write the app to start without them and serve a page saying what is missing, never exiting, and give the user the URL once its resources are attached. Apps are public: anyone with the URL can reach one, and there is no private mode yet, so say so before publishing organization data. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "description": {
            "description": "Required. One sentence saying what the app does.",
            "type": "string"
          },
          "discard_draft": {
            "description": "Set true to discard an open draft on this app that another session left. Omit to be told about it instead.",
            "type": "boolean"
          },
          "files": {
            "description": "Required. The app's files, [{path, content}]. A Procfile at the root is required.",
            "items": {
              "properties": {
                "content": {
                  "description": "Required. The file's complete text content.",
                  "type": "string"
                },
                "path": {
                  "description": "Required. The file's path, relative to the app root.",
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "idempotency_key": {
            "description": "An opaque key of your choosing. Repeating a call with the same key returns the first call's result instead of starting a second build. Use a new key for new files: a repeated key returns the earlier result even when the files changed.",
            "type": "string"
          },
          "name": {
            "description": "Required. The app's name, which becomes the last segment of its URL. Naming an app that exists republishes it.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization to publish into. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "title": {
            "description": "Required. What the app is called, written for a person.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "files",
          "title",
          "description"
        ],
        "type": "object"
      },
      "name": "publish_app",
      "outputSchema": null
    },
    {
      "description": "Publish files as a live website on the public internet, served over HTTPS. Use it when a report, essay, slide-like narrative, dashboard, marketing surface, or other static artifact reads better at a live URL than as conversation text. Honor an artifact form the user requests. Otherwise choose the artifact form and treatment from its audience, job, and material. A request for a live URL chooses delivery, not one long scrolling page.\n\nApply the governance skill before calling: get_skill with governance says what the organization expects of a published page and names the design-system skill, which supplies identity, not structure. Follow each wherever it speaks.\n\ntitle and description are required on every publish, and a call missing either is refused: title names the site for a person, and description says in one sentence what it holds. A site's name becomes part of its URL, so those two are what a reader has to go on wherever the site is listed. Write them for the person who will come back to this page in a month.\n\nContent is text written here: HTML, CSS, JavaScript, Markdown, JSON, SVG. Images, PDFs, video, and other binary assets are not supported on this surface — publish those with the Valet CLI.\n\nPublishing uses a connected Valet account by default and creates a permanent, private site. Pass anonymous: true only when the user explicitly wants a temporary public site. It is public to anyone who has the link, and it may be removed 36 hours after it is created, unless it is claimed. The result carries a claim URL that moves the site into a Valet account and makes it permanent, and a site_token that updates the same site on a later call. Give that token back to revise the site instead of publishing a second copy of it; with an account, give the site's name instead.",
      "inputSchema": {
        "properties": {
          "anonymous": {
            "description": "Set true only when the user explicitly wants a temporary public site without account ownership. Omit for the account-first path, which connects a Valet account when needed.",
            "type": "boolean"
          },
          "description": {
            "description": "Required. One sentence saying what the site holds, for a person deciding whether to open it. It is shown beside the title wherever the site is listed.",
            "maxLength": 1024,
            "minLength": 1,
            "type": "string"
          },
          "files": {
            "description": "Required. The site's files. One file named index.html is the minimum; add more for stylesheets, scripts, or further pages.",
            "items": {
              "properties": {
                "content": {
                  "description": "Required. The file's complete text content.",
                  "type": "string"
                },
                "path": {
                  "description": "Required. Path within the site, relative and with no leading slash: index.html, styles/main.css. It may not contain '..'.",
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "minItems": 1,
            "type": "array"
          },
          "idempotency_key": {
            "description": "An opaque key of your choosing. Repeating a call with the same key returns the first call's result instead of publishing a second site, which makes a retry safe.",
            "type": "string"
          },
          "name": {
            "description": "The site's name, which becomes the last segment of its URL, https://<org>.valet.run/<name>. Omit to have one generated. Naming a site that already exists republishes it. Requires a connected Valet account.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization to publish into. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "site_token": {
            "description": "The token an earlier anonymous publish returned. Give it back to update that same site instead of creating another.",
            "type": "string"
          },
          "title": {
            "description": "Required. What the site is called, written for a person: 'Q3 Migration Audit', not a hostname. It labels the site wherever it is listed, so write the same thing the page's own <title> says.",
            "maxLength": 1024,
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "files",
          "title",
          "description"
        ],
        "type": "object"
      },
      "name": "publish_site",
      "outputSchema": null
    },
    {
      "description": "Create or replace an organization skill from a SKILL.md and optional supporting files. The skill's name and description come from its frontmatter. Publishing under a well-known name, governance or design-system, replaces what Valet would otherwise supply for every agent in the organization from the next read on, so do it when the user has asked to change how the organization works, and show them the content first. Publishing under a new name adds a skill the default governance process finds through list_skills when its description applies.\n\nDestructive because it replaces the previous version's content for every reader. Repeating a call with identical content mints no new version and reports deduped. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "files": {
            "description": "Supporting files: [{path, content}], text only, paths relative to the skill root.",
            "items": {
              "properties": {
                "content": {
                  "description": "Required. The file's complete text content.",
                  "type": "string"
                },
                "path": {
                  "description": "Required. The file's path, relative to the skill root.",
                  "type": "string"
                }
              },
              "required": [
                "path",
                "content"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "org_name": {
            "description": "The Valet organization to publish into. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "skill_md": {
            "description": "Required. The complete SKILL.md, with name and description frontmatter.",
            "type": "string"
          }
        },
        "required": [
          "skill_md"
        ],
        "type": "object"
      },
      "name": "publish_skill",
      "outputSchema": null
    },
    {
      "description": "Rename a website or app and move it to https://<org>.valet.run/<new-name>. The old address stops serving it and its name becomes available to another site or app in the same organization. Pass kind to say which you mean; a name holding another kind is then refused rather than renamed. Agents are renamed with the Valet CLI. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "kind": {
            "description": "The kind you mean. Omit to rename whatever the name holds; give it to have a name holding another kind refused.",
            "enum": [
              "site",
              "app"
            ],
            "type": "string"
          },
          "name": {
            "description": "Required. The website's or app's current name.",
            "type": "string"
          },
          "new_name": {
            "description": "Required. The new name. It also becomes the last path segment of the new URL.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization it belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "new_name"
        ],
        "type": "object"
      },
      "name": "rename_service",
      "outputSchema": null
    },
    {
      "description": "Set environment variables on an app or agent, as name to value. A secret, the default, is encrypted and never shown again; plain configuration is readable from the dashboard. A value given here passes through this conversation, which is a real cost and the user's call: say that they could instead enter it on the dashboard, where it goes straight to Valet. Setting a name that exists replaces its value, which is why this is destructive. The process sees new values on its next start. The answer names the variables set and never their values. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "kind": {
            "description": "How to store them. Omit for secret.",
            "enum": [
              "secret",
              "plain"
            ],
            "type": "string"
          },
          "name": {
            "description": "Required. The app's or agent's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization it belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "vars": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Required. Variable name to value.",
            "type": "object"
          }
        },
        "required": [
          "name",
          "vars"
        ],
        "type": "object"
      },
      "name": "set_env_vars",
      "outputSchema": null
    },
    {
      "description": "Set who can reach a website: public serves it to anyone who has the link, private serves it only to members of the organization that owns it, and password serves it to anyone who enters a shared visitor password. Requires connecting a Valet account.\n\nPassword mode takes the password as the password argument. It is a shared visitor password the owner hands to whoever should see the site, not a Valet credential, and it is at most 72 bytes.",
      "inputSchema": {
        "properties": {
          "mode": {
            "description": "Required. The access mode. public serves the site to anyone who has the link. private serves it only to members of the organization that owns it. password serves it to anyone who enters the shared visitor password.",
            "enum": [
              "public",
              "private",
              "password"
            ],
            "type": "string"
          },
          "name": {
            "description": "Required. The site's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the site belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          },
          "password": {
            "description": "The shared visitor password. Required for password mode and rejected for the others. Anyone who enters it can open the site, so a site's owner passes it to whoever should see the page. At most 72 bytes.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "mode"
        ],
        "type": "object"
      },
      "name": "set_site_access",
      "outputSchema": null
    },
    {
      "description": "Share a website with specific people by email, whether it is private or password-protected — sharing does not change who else can reach it. Each address is mailed a link from Valet that opens the site; the recipient needs no Valet account of their own, only the link, so anyone holding the email can open the site and forwarding it forwards access. Sharing again with an address that already has access re-sends the same link rather than creating a second one. Requires connecting a Valet account.",
      "inputSchema": {
        "properties": {
          "access_ttl_seconds": {
            "description": "How many seconds of access the first open starts, after which the link stops working. Omit, or pass 0, for access that never expires this way. Composes with expires_in_seconds: the unopened deadline governs until the first open replaces it.",
            "minimum": 0,
            "type": "integer"
          },
          "emails": {
            "description": "Required. The email addresses to share the site with, at most 10 at a time. Sharing again with an address that already has access re-sends the same link rather than creating a second one.",
            "items": {
              "type": "string"
            },
            "minItems": 1,
            "type": "array"
          },
          "expires_in_seconds": {
            "description": "How many seconds from now the link stops working if nobody has opened it yet. Omit, or pass 0, for a link that never expires this way.",
            "minimum": 0,
            "type": "integer"
          },
          "message": {
            "description": "An optional note included in the email, shown to the recipient as a quote beside the link. At most 500 characters.",
            "type": "string"
          },
          "name": {
            "description": "Required. The site's name.",
            "type": "string"
          },
          "org_name": {
            "description": "The Valet organization the site belongs to. Omit to use the organization the account joined first.",
            "type": "string"
          }
        },
        "required": [
          "name",
          "emails"
        ],
        "type": "object"
      },
      "name": "share_site",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:0067ce0f1157b840e3010de00a3d062e2bd506ad2c2345ac0fa85f499c674a96 | sha256sum