WyndMe Private AI — developer reference

A private artificial-intelligence work platform. Every request runs on compute the account holder controls; no request, document, picture or video is handed to an outside model service, and nothing is retained anywhere else. The platform reads a request written the way a person would say it, works out which of its own abilities apply, carries them out — one after another where the work demands it — and reports both the answer and the steps it took.

What it can do, in short: hold a durable conversation with memory across sessions; research the live public internet without topic restriction and read any page; drive a real browser and interact with a site as a signed-in person would; retrieve an account's own stored documents and notes by meaning; write, revise and export finished word-processing documents, spreadsheets, slide decks and fixed-layout documents with real formatting; create pictures and change an existing picture while preserving its subject; create video and animate an exact still so the subject stays consistent; write, run and revise code; act inside a connected mail box, calendar, file store, document or spreadsheet on behalf of the person who signed in; and call any integration the account has switched on. Each ability declares its own inputs, worked examples and honest limits through the capabilities endpoint.

Three ways in, all equivalent: the application itself, this HTTP API, and a tool-protocol endpoint that assistants and agent frameworks attach to directly.

Human reference: https://wyndme.ai/developers
Machine reference: https://wyndme.ai/developers/llms.txt
Interface description: https://wyndme.ai/developers/openapi.json

Authentication

Every call carries an API key:

    Authorization: Bearer <your key>

The header `x-api-key: <your key>` is accepted as an alternative. A key identifies exactly one account; everything read or written through it stays inside that account. Keys are created and revoked from the account menu inside the application, are shown in full exactly once at creation, and are stored only as an irreversible fingerprint afterwards.

Each key may make 240 calls per minute. Exceeding that returns status 429 with a code of rate_limited; retry after the current minute ends.

Errors are always JSON: { "error": "a readable explanation", "code": "machine_readable_code", "request_id": "…" }. Quote the request id when asking for help. Cross-origin browser calls are permitted, so a key placed in a browser is exposed to whoever uses that browser; call from your own server whenever the key must stay secret.

Endpoints

Base address: https://wyndme.ai/api/public/v1

GET /me — Identify the account behind a key

Returns the account a key belongs to and the key's own name. Use it to confirm a key works before wiring anything else, and to label the connection inside your own product.

Response:
{ "account_id": "…", "key_name": "Default key", "profile": { "display_name": "…" } }

POST /chat — Ask in plain words and let the platform choose how to answer

The main entry point. Send a request written the way a person would say it. The platform reads the request, decides on its own which of its abilities apply, and carries them out before answering: searching the live public web and reading pages, opening a real browser and interacting with a site, retrieving stored knowledge, writing or revising a document, creating or editing a picture, creating or animating video, running code, working inside a connected mail box, calendar, file store, document or spreadsheet, and calling any integration switched on for the account. Multiple abilities are combined in one request when the work needs it, and each step it took is reported back. Conversations are durable: pass the returned conversation id on the next call to continue with full memory of what came before. By default the answer streams token by token as it is produced; set stream to false to receive the complete answer, the list of actions taken and the sources consulted in one JSON object instead.

Request body:
{
  "message": "Research this week's changes to EU AI rules, then write me a two-page briefing as a PDF",
  "conversation_id": "optional — continue an earlier conversation",
  "project_id": "optional — file the work under a project",
  "role": "auto | chat | code | vision  (optional; auto is correct almost always)",
  "stream": true
}

Response:
Streaming: text/event-stream. Each line is "data: {…}".
  { "type": "conversation", "id": "…" }        the conversation this turn belongs to
  { "type": "delta", "text": "…" }            a piece of the answer as it is written
  { "type": "tool_start", "tool": "…", "label": "…" }   an ability being used
  { "type": "tool_result", "tool": "…", "ok": true, "detail": "…" }
  { "type": "artifact", … }                   a document or file that was produced
  { "type": "sources", "sources": [ { "title": "…", "url": "…" } ] }
  { "type": "done" }

Non-streaming: { "reply": "…", "conversation_id": "…", "tool_calls": [ … ], "sources": [ … ] }

POST /images — Create a picture, or change an existing one while keeping its subject

Describe the picture you want and it is produced on the account's own private hardware. Supply source_image_id instead, together with a description of the change, and the existing picture is used as the reference so its subject is preserved: the same room, the same stage, the same architectural detail, or the same person, across a new outfit, a new setting or a new lighting condition. The strength value controls how far the result may drift from the reference, from a light retouch to a substantial reinterpretation. Aspect ratio and an optional description of what to avoid are both accepted. Each result is stored in the account's own library and returned as an address you can fetch.

Request body:
{
  "prompt": "the picture, or the change to make, described in words",
  "source_image_id": "optional — keep this picture's subject and change the rest",
  "strength": 0.35,
  "aspect_ratio": "16:9 | 1:1 | 9:16 | 4:3 | 3:4",
  "negative_prompt": "optional — what to avoid",
  "project_id": "optional"
}

Response:
{ "ok": true, "result": "a description of what was produced", "assets": [ "https://…" ] }

POST /videos — Create video, or bring an existing picture to life

Describe a moving sequence and it is rendered on the account's own private hardware. Supply source_image_id and the exact picture is animated, so the subject in the resulting footage is the same subject in the still — essential for a venue that must remain recognisable, or a character who must stay consistent across a series. Duration and aspect ratio are accepted, and the real measured properties of the finished file are recorded alongside it rather than assumed.

Request body:
{
  "prompt": "what should happen in the shot",
  "source_image_id": "optional — animate this exact picture",
  "duration_seconds": 5,
  "aspect_ratio": "16:9 | 1:1 | 9:16",
  "project_id": "optional"
}

Response:
{ "ok": true, "result": "…", "assets": [ "https://…" ] }

POST /documents — Turn structured content into a finished, formatted file

Send a title and content written in ordinary markdown and receive a finished file, formatted with a heading hierarchy, coloured summary cards, columns, tables, bullet lists and numbered lists. Four formats are produced: a word-processing document, a spreadsheet, a slide deck, and a fixed-layout document for printing and sharing. Tables in the content become real tables; headings become real headings, slide titles or sheet sections depending on the format chosen. The response is the file itself.

Request body:
{
  "title": "Quarterly briefing",
  "content": "# Summary\n\n- point one\n- point two\n\n## Detail\n\n| Item | Value |\n| --- | --- |\n| A | 1 |",
  "format": "docx | xlsx | pptx | pdf"
}

Response:
The binary file, with the matching content type and a download file name.

POST /knowledge/search — Search the account's own stored knowledge

Searches the documents and notes the account has added to its private knowledge base by meaning rather than exact wording, and returns the passages that answer the question together with which document each came from. Nothing outside the account is consulted.

Request body:
{ "query": "what did we agree about refund windows?", "limit": 8, "project_id": "optional" }

Response:
{ "ok": true, "result": "matching passages with their sources" }

GET /capabilities — List every ability, with its inputs, examples and limits

A complete machine-readable description of everything the platform can do: each ability's name, what it is for, whether it reads or changes something, the exact inputs it accepts, worked examples, and its honest limitations. Built for other software to read at start-up so it can decide what to call, and kept in step automatically as abilities are added.

Response:
{ "capabilities": [ { "app": "web", "name": "Search the web", "action": "web_search", "inputs": { … }, "examples": [ … ], "limits": [ … ] } ] }

GET /apps — List apps and integrations

Returns the whole directory: the apps already switched on for this account, the shared apps available to switch on with one call, and the apps this account added itself. Each entry carries its full documentation, the actions it contributes, whether it needs a personal sign-in, and whether it is private to this account or shared with everyone.

Response:
{ "apps": [ { "slug": "…", "name": "…", "installed": true, "visibility": "public", "capabilities": [ … ] } ] }

POST /apps — Add a new app or integration

Adds an integration that is not in the directory yet. Supply a name, a summary, optional full documentation, how it authenticates and the address it calls; the address is checked immediately and the result recorded. A new app starts private to the account that added it, and can be shared with everyone on the platform by setting visibility to public. No review or approval step stands in the way.

Request body:
{
  "name": "Our CRM",
  "summary": "Reads and updates customer records.",
  "documentation": "Full detail of the actions, inputs and limits, for other software to read.",
  "category": "crm",
  "visibility": "private | public",
  "auth_type": "none | account_connection | api_key | oauth | basic | bearer",
  "base_url": "https://…"
}

Response:
{ "app": { "slug": "our-crm", … }, "verification": "The address answered with status 200." }

POST /apps/{slug}/install — Switch an app on

Switches an app on for this account so its actions become usable immediately, in conversation, over this API and over the tool protocol. When the app works on a personal account, the response says a sign-in is still required.

Response:
{ "app": "…", "status": "installed | needs_connection", "needs_sign_in": false }

DELETE /apps/{slug} — Switch an app off

Switches the app off for this account, so its actions stop being offered in conversation, over this API and over the tool protocol. Nothing is destroyed: the app itself, its documentation and anything it produced all remain, and it can be switched back on at any time with a single call. Switching an app off does not sign you out of any account you connected to it.

Response:
{ "app": "…", "status": "removed" }

Tool protocol endpoint

    https://wyndme.ai/api/public/mcp

The same abilities are exposed as a tool server that assistants and agent frameworks can attach to directly, spoken over JSON-RPC across a single HTTP address. Authenticate with the same API key as a bearer token. The methods supported are initialize, tools/list, tools/call and ping. Send `Accept: application/json, text/event-stream`.

`tools/list` returns the live tool set: one high-level `ask` tool that takes a request in plain words and decides for itself which abilities to combine, plus a specific tool for every individual ability and every action contributed by an integration switched on for the account. The list changes as apps are switched on, so read it at start-up rather than hard-coding it.

A worked exchange:

    POST https://wyndme.ai/api/public/mcp
    Authorization: Bearer <your key>
    Content-Type: application/json
    Accept: application/json, text/event-stream

    { "jsonrpc": "2.0", "id": 1, "method": "tools/call",
      "params": { "name": "ask", "arguments": { "message": "Summarise our refund policy and export it as a PDF" } } }

The reply carries the answer as text content, and a flag when the action failed.

Full capability catalogue

Everything below is available in conversation, over the HTTP API and over the tool protocol, with identical behaviour. The assistant selects these on its own from a request written in plain words, so naming one is never required.

Web research.

Search the live public internet and read any http(s) page, with no topic, domain or content restrictions.

This app groups 2 actions in the "web" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

Actions:

- Search the web (`web_search`)
  What it does: Search the live public internet and return ranked results with page text.
  Kind of action: read.
  Inputs:
    * query (string, required): Natural-language search query.
    * num_results (integer, optional): See the action description.
    * recent_only (boolean, optional): See the action description.
  Example requests:
    * What changed in the EU AI Act this quarter?
    * Find current the private compute fleet high-memory accelerators pricing.
  Limits and honest caveats:
    * Reads public pages only — sites behind a login need a browser connection.

- Read a page (`fetch_url`)
  What it does: Fetch a specific http(s) URL and return its readable text.
  Kind of action: read.
  Inputs:
    * url (string, required): Absolute http or https URL.
    * max_characters (integer, optional): See the action description.
  Example requests:
    * Summarise this article: <url>
  Limits and honest caveats:
    * Cannot log in; JavaScript-only pages may return little text.

Real browser.

Open pages in a real headless Chromium running on private the private compute fleet CPU compute, read JavaScript-rendered content, and click, type and scroll through multi-step flows.

This app groups 2 actions in the "browser" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

Actions:

- Open a page in a browser (`browse_page`)
  What it does: Render a page in a real browser and return its visible text, for sites that need JavaScript to show their content.
  Kind of action: read.
  Inputs:
    * url (string, required): Absolute http or https URL.
    * max_characters (integer, optional): See the action description.
    * include_links (boolean, optional): See the action description.
  Example requests:
    * Open this dashboard page and tell me what it says.
    * This article did not load with a plain fetch — try the browser.
  Limits and honest caveats:
    * Requires the browser worker service to be active.
    * Refuses private and loopback addresses.

- Interact with a page (`browse_interact`)
  What it does: Perform a short sequence of clicks, keystrokes, selections, scrolls and waits on a page, then read the result.
  Kind of action: modify.
  Inputs:
    * url (string, required): Absolute http or https URL to open first.
    * steps (array, required): See the action description.
    * max_characters (integer, optional): See the action description.
  Example requests:
    * Search this site for "pricing" and summarise the first result.
    * Accept the cookie banner and read the full article.
  Limits and honest caveats:
    * Requires the browser worker service to be active.
    * Interactions are subject to your autonomy settings; set browser to autonomous to run them without asking.

Documents.

Produce branded Word, Excel, PowerPoint and PDF deliverables from the content of a conversation, and edit them live in the workspace editor.

This app groups 1 action in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

Actions:

- Create a document (`create_document`)
  What it does: Turn drafted content into a formatted DOCX, XLSX, PPTX or PDF artifact saved to the workspace.
  Kind of action: create.
  Inputs:
    * title (string, required): Document title.
    * format (string, required): See the action description.
    * markdown (string, required): Full document body in markdown. Headings become sections, tables become real tables, bullet and numbered lists are preserved.
  Example requests:
    * Put that analysis into a Word document.
    * Build a 3-slide summary deck.
  Limits and honest caveats:
    * Charts are rendered as tables; images are not embedded yet.

Images and video.

Generate images and video entirely on the private the private compute fleet GPU runtimes. No third-party inference credits are used.

This app groups 2 actions in the "media" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

Actions:

- Generate an image (`generate_image`)
  What it does: Render an image from a text prompt on the private image runtime.
  Kind of action: create.
  Inputs:
    * prompt (string, required): See the action description.
    * width (integer, optional): See the action description.
    * height (integer, optional): See the action description.
  Example requests:
    * Generate a hero image for the pricing page.
  Limits and honest caveats:
    * Requires the private image runtime to be active.

- Generate a video (`generate_video`)
  What it does: Render a short video from a text prompt or a source image on the private video runtime.
  Kind of action: create.
  Inputs:
    * prompt (string, required): See the action description.
    * seconds (integer, optional): See the action description.
  Example requests:
    * Make a 5-second clip of the product rotating.
  Limits and honest caveats:
    * Requires the private video runtime; long-form renders go through the Video Studio.

UI design.

Generate UI directions and frontend code with your connected account the interface design engine, following the repository brand rules.

This app groups 1 action in the "design" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

Actions:

- Design a screen (`design_ui`)
  What it does: Produce a UI design and matching frontend code for a described screen.
  Kind of action: create.
  Inputs:
    * screen (string, required): What the screen must do.
    * device (string, optional): See the action description.
  Example requests:
    * Design a GPU runtimes dashboard.
  Limits and honest caveats:
    * Output is a starting point; it is adapted to the existing design system before use.

Self-description.

Report, from the live registry, exactly which capabilities exist, which are enabled and what is missing.

This app groups 1 action in the "knowledge" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

Actions:

- Describe capabilities (`describe_capabilities`)
  What it does: List the current skills and capabilities with their real status, so questions about what can be done are answered from data.
  Kind of action: read.
  Inputs:
    * category (string, optional): Optional skill category filter.
    * only_unavailable (boolean, optional): List only what is not currently usable.
  Example requests:
    * What can you do?
    * Can you manage your connected work account?
    * What is disabled right now?

your connected mail account.

Search, read and send mail from the user's own your connected mail account account through their personal connection.

This app groups 3 actions in the "communication" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Search mail (`gmail_search_messages`)
  What it does: Find messages using your connected mail account search syntax and return their summaries.
  Kind of action: read.
  Inputs:
    * query (string, required): See the action description.
    * max_results (integer, optional): See the action description.
  Example requests:
    * Any unread mail from finance this week?

- Read a message (`gmail_read_message`)
  What it does: Read the full text of one message by id.
  Kind of action: read.
  Inputs:
    * message_id (string, required): See the action description.

- Send an email (`gmail_send_message`)
  What it does: Send a plain-text email from the connected address.
  Kind of action: send.
  Inputs:
    * to (string, required): See the action description.
    * subject (string, required): See the action description.
    * body (string, required): See the action description.
    * cc (string, optional): See the action description.
    * bcc (string, optional): See the action description.
  Limits and honest caveats:
    * Plain text only — attachments are not sent.

your connected calendar.

Read the user's schedule and create events on their own calendars.

This app groups 2 actions in the "productivity" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- List events (`calendar_list_events`)
  What it does: List upcoming events in a time window.
  Kind of action: read.
  Inputs:
    * calendar_id (string, optional): See the action description.
    * time_min (string, optional): See the action description.
    * time_max (string, optional): See the action description.
    * max_results (integer, optional): See the action description.

- Create an event (`calendar_create_event`)
  What it does: Create a calendar event, optionally inviting attendees.
  Kind of action: create.
  Inputs:
    * summary (string, required): See the action description.
    * start (string, required): See the action description.
    * end (string, required): See the action description.
    * attendees (array, optional): See the action description.

your connected file storage.

Search the user's Drive and read the text of their files.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Search files (`drive_search_files`)
  What it does: Find files by name or content.
  Kind of action: read.
  Inputs:
    * query (string, required): See the action description.
    * max_results (integer, optional): See the action description.

- Read a file (`drive_read_file`)
  What it does: Read a file's text, exporting your connected account formats automatically.
  Kind of action: read.
  Inputs:
    * file_id (string, required): See the action description.
  Limits and honest caveats:
    * Binary files such as images and video return no readable text.

your connected documents.

Read your connected documents and create new documents in the user's Drive.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Read a document (`docs_read_document`)
  What it does: Read the text of a your connected account Doc.
  Kind of action: read.
  Inputs:
    * document_id (string, required): See the action description.

- Create a document (`docs_create_document`)
  What it does: Create a your connected account Doc with a title and body.
  Kind of action: create.
  Inputs:
    * title (string, required): See the action description.
    * body (string, optional): See the action description.

your connected spreadsheets.

Read ranges from the user's spreadsheets and append rows to them.

This app groups 2 actions in the "data" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Read a range (`sheets_read_range`)
  What it does: Read cells from a spreadsheet range.
  Kind of action: read.
  Inputs:
    * spreadsheet_id (string, required): See the action description.
    * range (string, required): See the action description.

- Append rows (`sheets_append_rows`)
  What it does: Append rows of values to a spreadsheet.
  Kind of action: modify.
  Inputs:
    * spreadsheet_id (string, required): See the action description.
    * range (string, required): See the action description.
    * rows (array, required): See the action description.

your connected account Slides.

Read the text of the user's presentations and create new ones.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Read a presentation (`slides_read_presentation`)
  What it does: Read the slide-by-slide text of a presentation.
  Kind of action: read.
  Inputs:
    * presentation_id (string, required): See the action description.

- Create a presentation (`slides_create_presentation`)
  What it does: Create a new presentation with a title.
  Kind of action: create.
  Inputs:
    * title (string, required): See the action description.

your connected account Outlook.

Search and send Outlook mail and work with the user's Outlook calendar.

This app groups 4 actions in the "communication" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Search mail (`outlook_search_messages`)
  What it does: Search the connected Outlook mailbox and return message summaries.
  Kind of action: read.
  Inputs:
    * query (string, required): See the action description.
    * max_results (integer, optional): See the action description.

- Send an email (`outlook_send_message`)
  What it does: Send a plain-text email from the connected Outlook address.
  Kind of action: send.
  Inputs:
    * to (string, required): See the action description.
    * subject (string, required): See the action description.
    * body (string, required): See the action description.
    * cc (string, optional): See the action description.
  Limits and honest caveats:
    * Plain text only — attachments are not sent.

- List events (`outlook_list_events`)
  What it does: List upcoming Outlook calendar events in a time window.
  Kind of action: read.
  Inputs:
    * time_min (string, optional): See the action description.
    * time_max (string, optional): See the action description.
    * max_results (integer, optional): See the action description.

- Create an event (`outlook_create_event`)
  What it does: Create an Outlook calendar event, optionally inviting attendees.
  Kind of action: create.
  Inputs:
    * subject (string, required): See the action description.
    * start (string, required): See the action description.
    * end (string, required): See the action description.
    * attendees (array, optional): See the action description.

your connected account Teams.

See the user's teams and channels and post messages to a channel.

This app groups 2 actions in the "communication" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- List teams and channels (`teams_list_channels`)
  What it does: List the teams the user belongs to and their channels.
  Kind of action: read.
  Inputs:
    * team_id (string, optional): See the action description.

- Post to a channel (`teams_send_channel_message`)
  What it does: Post a message to a Teams channel as the connected user.
  Kind of action: send.
  Inputs:
    * team_id (string, required): See the action description.
    * channel_id (string, required): See the action description.
    * message (string, required): See the action description.

your connected account SharePoint.

Find SharePoint sites the user can reach and list the files they hold.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Find sites (`sharepoint_search_sites`)
  What it does: Search SharePoint sites by name.
  Kind of action: read.
  Inputs:
    * query (string, required): See the action description.

- List site files (`sharepoint_list_site_files`)
  What it does: List files in a SharePoint site's default document library.
  Kind of action: read.
  Inputs:
    * site_id (string, required): See the action description.
    * max_results (integer, optional): See the action description.

your connected account OneDrive.

Search the user's OneDrive and read the text of their files.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Search files (`onedrive_search_files`)
  What it does: Search OneDrive by file name or content.
  Kind of action: read.
  Inputs:
    * query (string, required): See the action description.
    * max_results (integer, optional): See the action description.

- Read a file (`onedrive_read_file`)
  What it does: Read the text content of a OneDrive file.
  Kind of action: read.
  Inputs:
    * item_id (string, required): See the action description.
  Limits and honest caveats:
    * Binary files such as images and video return no readable text.

your connected account Word.

List the user's Word documents and read the text of one.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- List documents (`word_list_documents`)
  What it does: List Word documents in the user's own files.
  Kind of action: read.
  Inputs:
    * query (string, optional): See the action description.
    * max_results (integer, optional): See the action description.

- Read a document (`word_read_document`)
  What it does: Read the text of a Word document.
  Kind of action: read.
  Inputs:
    * item_id (string, required): See the action description.

your connected account Excel.

Read ranges from the user's workbooks and add rows to them.

This app groups 2 actions in the "data" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Read a range (`excel_read_range`)
  What it does: Read cells from a worksheet range in a workbook.
  Kind of action: read.
  Inputs:
    * item_id (string, required): See the action description.
    * worksheet (string, optional): See the action description.
    * range (string, required): See the action description.

- Add a row (`excel_append_row`)
  What it does: Add a row of values to a worksheet table range.
  Kind of action: modify.
  Inputs:
    * item_id (string, required): See the action description.
    * worksheet (string, optional): See the action description.
    * range (string, required): See the action description.
    * values (array, required): See the action description.

your connected account PowerPoint.

List the user's presentations and fetch one for editing or sharing.

This app groups 2 actions in the "documents" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- List presentations (`powerpoint_list_presentations`)
  What it does: List PowerPoint files in the user's own files.
  Kind of action: read.
  Inputs:
    * query (string, optional): See the action description.
    * max_results (integer, optional): See the action description.

- Get a presentation (`powerpoint_get_presentation`)
  What it does: Fetch a presentation's details and a link to open it.
  Kind of action: read.
  Inputs:
    * item_id (string, required): See the action description.

your connected account OneNote.

Search the user's notebooks and add new pages to them.

This app groups 2 actions in the "productivity" area of work. Once installed, every action below can be used in three ways that behave identically: by asking the assistant in conversation, by calling the HTTP API, and by calling the equivalent tool over the machine-to-machine tool protocol. The assistant decides on its own when an action is the right one for a request, so a caller never has to name it explicitly.

This app acts on an account that belongs to the person using it. Installing it walks straight into signing in to that account; nothing is read or written until that sign-in is complete, and each person's data stays scoped to their own account.

Actions:

- Search pages (`onenote_search_pages`)
  What it does: Search OneNote pages by title.
  Kind of action: read.
  Inputs:
    * query (string, required): See the action description.
    * max_results (integer, optional): See the action description.

- Create a page (`onenote_create_page`)
  What it does: Create a new OneNote page in a section.
  Kind of action: create.
  Inputs:
    * section_id (string, required): See the action description.
    * title (string, required): See the action description.
    * body (string, optional): See the action description.