Depot aisettings

View as Markdown Open in ChatGPT Open in Claude

Registers the AI routes on the practice face, plus the per-client override.

This page is generated from the Depot route table. Every operation carries the permission it needs and the anchor an agent can link to.

POST `/api/v1/ai/chat`

POSTshared facehosteditmspremoteServer sent eventsNot fully resolved

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

What this page does not know

response

These are parts of the route the extractor could not read from the source. Everything else on this page came straight from it.

Source: [object Object]

Chat

Request body

Required, sent as application/json.

Field	Type	Description
`clientId`required	`string`
`messages`required	`array of Message`
`messages[].content`required	`array of Block`
`messages[].content[].data`	`string`
`messages[].content[].input`	`any`	Arbitrary JSON.
`messages[].content[].isError`	`boolean`
`messages[].content[].mediaType`	`string`
`messages[].content[].text`	`string`
`messages[].content[].toolName`	`string`
`messages[].content[].toolUseId`	`string`
`messages[].content[].type`required	`string`
`messages[].role`required	`string, one of assistant, system, user`
`tier`required	`string`

Responses

Status	Body	Description
`200`	`text/event-stream`, string	Success. The body shape was not resolved; see x-outpost-unresolved.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`404`	`application/problem+json`, ProblemDetails	No such client.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.
curl -X POST 'https://depot.example.com/api/v1/ai/chat' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "clientId": "string",
  "messages": [
    {
      "content": [
        {
          "data": "string",
          "input": "string",
          "isError": false,
          "mediaType": "string",
          "text": "string",
          "toolName": "string",
          "toolUseId": "string",
          "type": "string"
        }
      ],
      "role": "assistant"
    }
  ],
  "tier": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "clientId": "string",
  "messages": [
    {
      "content": [
        {
          "data": "string",
          "input": "string",
          "isError": false,
          "mediaType": "string",
          "text": "string",
          "toolName": "string",
          "toolUseId": "string",
          "type": "string"
        }
      ],
      "role": "assistant"
    }
  ],
  "tier": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/chat' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.

import requests

url = "https://depot.example.com/api/v1/ai/chat"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "clientId": "string",
    "messages": [
        {
            "content": [
                {
                    "data": "string",
                    "input": "string",
                    "isError": False,
                    "mediaType": "string",
                    "text": "string",
                    "toolName": "string",
                    "toolUseId": "string",
                    "type": "string",
                },
            ],
            "role": "assistant",
        },
    ],
    "tier": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "clientId": "string",
  "messages": [
    {
      "content": [
        {
          "data": "string",
          "input": "string",
          "isError": false,
          "mediaType": "string",
          "text": "string",
          "toolName": "string",
          "toolUseId": "string",
          "type": "string"
        }
      ],
      "role": "assistant"
    }
  ],
  "tier": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/chat", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/chat";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "clientId": "string",
    "messages": [
      {
        "content": [
          {
            "data": "string",
            "input": "string",
            "isError": false,
            "mediaType": "string",
            "text": "string",
            "toolName": "string",
            "toolUseId": "string",
            "type": "string"
          }
        ],
        "role": "assistant"
      }
    ],
    "tier": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "clientId": "string",
  "messages": [
    {
      "content": [
        {
          "data": "string",
          "input": "string",
          "isError": false,
          "mediaType": "string",
          "text": "string",
          "toolName": "string",
          "toolUseId": "string",
          "type": "string"
        }
      ],
      "role": "assistant"
    }
  ],
  "tier": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/chat");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

listConversations returns your Pioneer AI conversations, most recent activity first.

With all=1 and ai:review, every user’s. q searches the titles of the 500 most recent (pioneer_rewind.go). pinned=true or false narrows to the pinned conversations or the others (section 17).

Parameters

Name	In	Type	Required
`all`	query	string	No
`cursor`	query	string	No
`limit`	query	string	No
`pinned`	query	string	No
`q`	query	string	No

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations?all=<all>&cursor=<cursor>&limit=<limit>&pinned=<pinned>&q=<q>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations?all=<all>&cursor=<cursor>&limit=<limit>&pinned=<pinned>&q=<q>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations"
params = {
    "all": "<all>",
    "cursor": "<cursor>",
    "limit": "<limit>",
    "pinned": "<pinned>",
    "q": "<q>",
}
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, params=params, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations?all=<all>&cursor=<cursor>&limit=<limit>&pinned=<pinned>&q=<q>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = new URL("https://depot.example.com/api/v1/ai/conversations");
url.searchParams.set("all", "<all>");
url.searchParams.set("cursor", "<cursor>");
url.searchParams.set("limit", "<limit>");
url.searchParams.set("pinned", "<pinned>");
url.searchParams.set("q", "<q>");

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations?all=<all>&cursor=<cursor>&limit=<limit>&pinned=<pinned>&q=<q>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

createConversation starts an empty Pioneer AI conversation.

On the MSP console clientId pins the client it is about.

Request body

Required, sent as application/json.

Field	Type	Description
`clientId`required	`string`
`tier`required	`string`

Responses

Status	Body	Description
`201`	`application/json`, PioneerConvView	Created.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such client.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

201 response body

Field	Type	Description
`clientId`	`string or null`
`contextTokens`required	`integer`
`contextWindow`required	`integer`
`createdAt`required	`string (date-time)`
`id`required	`string`
`lastActivityAt`required	`string (date-time)`
`ownerName`required	`string`
`ownerUserId`required	`string`
`pending`	`PioneerPending`	PioneerPending is "PioneerConversation"."PendingJson": ids only, never the tool arguments.
`pending.approvalId`required	`string`
`pending.tool`required	`string`
`pending.toolUseId`required	`string`
`pinned`required	`boolean`
`status`required	`string`
`tier`	`string or null`
`title`required	`string`
`totals`required	`PioneerTotalsView`
`totals.cacheReadTokens`required	`integer`	int64.
`totals.cacheWriteTokens`required	`integer`	int64.
`totals.costMicroCents`required	`integer`	int64.
`totals.inputTokens`required	`integer`	int64.
`totals.outputTokens`required	`integer`	int64.
`totals.reasoningTokens`required	`integer`	int64.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "clientId": "string",
  "tier": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "clientId": "string",
  "tier": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "clientId": "string",
    "tier": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "clientId": "string",
  "tier": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "clientId": "string",
    "tier": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "clientId": "string",
  "tier": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

getConversation returns one conversation with its messages.

An ai:review holder may read anybody’s, read-only; every such view is audited.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, PioneerConvDetail	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`clientId`	`string or null`
`contextTokens`required	`integer`
`contextWindow`required	`integer`
`createdAt`required	`string (date-time)`
`id`required	`string`
`lastActivityAt`required	`string (date-time)`
`messages`required	`array of PioneerMsgView`
`messages[].attachments`	`array of AttachmentMeta`
`messages[].attachments[].kind`required	`string, one of diagram, image, text`
`messages[].attachments[].mediaType`required	`string`
`messages[].attachments[].name`required	`string`
`messages[].attachments[].size`required	`integer`
`messages[].blocks`required	`array of PioneerBlockView`
`messages[].blocks[].data`	`string`
`messages[].blocks[].impactReason`	`string`
`messages[].blocks[].input`	`any`	Arbitrary JSON.
`messages[].blocks[].isError`	`boolean`
`messages[].blocks[].mediaType`	`string`
`messages[].blocks[].text`	`string`
`messages[].blocks[].tier`	`string`
`messages[].blocks[].toolName`	`string`
`messages[].blocks[].toolUseId`	`string`
`messages[].blocks[].type`required	`string`
`messages[].changes`	`array of string`
`messages[].createdAt`required	`string (date-time)`
`messages[].feedback`	`integer or null`
`messages[].mentions`	`array of MentionMeta`
`messages[].mentions[].kind`required	`string`
`messages[].mentions[].name`required	`string`
`messages[].page`required	`any`	Arbitrary JSON.
`messages[].role`required	`string`
`messages[].seq`required	`integer`
`ownerName`required	`string`
`ownerUserId`required	`string`
`pending`	`PioneerPending`	PioneerPending is "PioneerConversation"."PendingJson": ids only, never the tool arguments.
`pending.approvalId`required	`string`
`pending.tool`required	`string`
`pending.toolUseId`required	`string`
`pinned`required	`boolean`
`queued`	`array of PioneerQueuedView`
`queued[].attachmentErrors`	`array of AttachmentErrorData`
`queued[].attachmentErrors[].message`required	`string`
`queued[].attachmentErrors[].name`required	`string`
`queued[].attachments`	`array of AttachmentMeta`
`queued[].attachments[].kind`required	`string, one of diagram, image, text`
`queued[].attachments[].mediaType`required	`string`
`queued[].attachments[].name`required	`string`
`queued[].attachments[].size`required	`integer`
`queued[].createdAt`required	`string (date-time)`
`queued[].id`required	`string`
`queued[].mentions`	`array of MentionMeta`
`queued[].mentions[].kind`required	`string`
`queued[].mentions[].name`required	`string`
`queued[].text`required	`string`
`reviewOnly`required	`boolean`
`status`required	`string`
`tier`	`string or null`
`title`required	`string`
`totals`required	`PioneerTotalsView`
`totals.cacheReadTokens`required	`integer`	int64.
`totals.cacheWriteTokens`required	`integer`	int64.
`totals.costMicroCents`required	`integer`	int64.
`totals.inputTokens`required	`integer`	int64.
`totals.outputTokens`required	`integer`	int64.
`totals.reasoningTokens`required	`integer`	int64.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH `/api/v1/ai/conversations/{id}`

PATCHai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

renameConversation changes a conversation’s title, pin or tier: any of them, at least one (section 17).

A tier must be one this organization can run on now; it applies from the next turn, and the context window follows.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`pinned`	`boolean or null`
`tier`	`string or null`
`title`	`string or null`

Responses

Status	Body	Description
`200`	`application/json`, PioneerConvView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not update the conversation.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`clientId`	`string or null`
`contextTokens`required	`integer`
`contextWindow`required	`integer`
`createdAt`required	`string (date-time)`
`id`required	`string`
`lastActivityAt`required	`string (date-time)`
`ownerName`required	`string`
`ownerUserId`required	`string`
`pending`	`PioneerPending`	PioneerPending is "PioneerConversation"."PendingJson": ids only, never the tool arguments.
`pending.approvalId`required	`string`
`pending.tool`required	`string`
`pending.toolUseId`required	`string`
`pinned`required	`boolean`
`status`required	`string`
`tier`	`string or null`
`title`required	`string`
`totals`required	`PioneerTotalsView`
`totals.cacheReadTokens`required	`integer`	int64.
`totals.cacheWriteTokens`required	`integer`	int64.
`totals.costMicroCents`required	`integer`	int64.
`totals.inputTokens`required	`integer`	int64.
`totals.outputTokens`required	`integer`	int64.
`totals.reasoningTokens`required	`integer`	int64.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X PATCH 'https://depot.example.com/api/v1/ai/conversations/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "pinned": false,
  "tier": "string",
  "title": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "pinned": false,
  "tier": "string",
  "title": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Patch `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "pinned": False,
    "tier": "string",
    "title": "string",
}

response = requests.patch(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "pinned": false,
  "tier": "string",
  "title": "string"
}`)

  req, err := http.NewRequest(http.MethodPatch, "https://depot.example.com/api/v1/ai/conversations/<id>", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>";

const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "pinned": false,
    "tier": "string",
    "title": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "pinned": false,
  "tier": "string",
  "title": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Patch, "https://depot.example.com/api/v1/ai/conversations/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE `/api/v1/ai/conversations/{id}`

DELETEai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

deleteConversation deletes a conversation, its messages and its pending approvals, and closes any shell it opened.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not delete the conversation.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X DELETE 'https://depot.example.com/api/v1/ai/conversations/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Delete `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.delete(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodDelete, "https://depot.example.com/api/v1/ai/conversations/<id>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>";

const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "https://depot.example.com/api/v1/ai/conversations/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}/actions`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

listActions returns the conversation’s tool calls in order: what each did, how it ended, and whether Undo can reverse it, with what the reversal does and its tier.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>/actions' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/actions' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/actions"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>/actions", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/actions";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>/actions");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}/diagrams/{toolUseId}`

GETai:useshared facehosteditmspremoteIdempotentdownloadNot fully resolved

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

What this page does not know

response

These are parts of the route the extractor could not read from the source. Everything else on this page came straight from it.

Source: [object Object]

getDiagram renders one create_diagram call of a conversation as .drawio, PNG or the laid-out graph JSON (NETWORK_MAP_CONTRACTS.md 7.3).

The owner, or an ai:review holder (audited), may download it.

Parameters

Name	In	Type	Required
`id`	path	string	Yes
`toolUseId`	path	string	Yes
`format`	query	string	No

Responses

Status	Body	Description
`200`	`application/octet-stream`, string (binary)	Success. The body shape was not resolved; see x-outpost-unresolved.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>/diagrams/<toolUseId>?format=<format>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/diagrams/<toolUseId>?format=<format>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/diagrams/<toolUseId>"
params = {
    "format": "<format>",
}
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, params=params, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>/diagrams/<toolUseId>?format=<format>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = new URL("https://depot.example.com/api/v1/ai/conversations/<id>/diagrams/<toolUseId>");
url.searchParams.set("format", "<format>");

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>/diagrams/<toolUseId>?format=<format>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}/documents/{toolUseId}`

GETai:useshared facehosteditmspremoteIdempotentdownloadNot fully resolved

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

What this page does not know

response

These are parts of the route the extractor could not read from the source. Everything else on this page came straight from it.

Source: [object Object]

getDocument renders one create_document call of a conversation as Markdown, PDF or Word.

The owner, or an ai:review holder (audited), may download it.

Parameters

Name	In	Type	Required
`id`	path	string	Yes
`toolUseId`	path	string	Yes
`format`	query	string	No

Responses

Status	Body	Description
`200`	`application/octet-stream`, string (binary)	Success. The body shape was not resolved; see x-outpost-unresolved.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>/documents/<toolUseId>?format=<format>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/documents/<toolUseId>?format=<format>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/documents/<toolUseId>"
params = {
    "format": "<format>",
}
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, params=params, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>/documents/<toolUseId>?format=<format>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = new URL("https://depot.example.com/api/v1/ai/conversations/<id>/documents/<toolUseId>");
url.searchParams.set("format", "<format>");

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>/documents/<toolUseId>?format=<format>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/messages`

POSTshared facehosteditmspremoteServer sent eventsNot fully resolved

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

What this page does not know

response

These are parts of the route the extractor could not read from the source. Everything else on this page came straight from it.

Source: [object Object]

postMessage sends a message to Pioneer AI and streams the turn as server-sent events: text as it is written, each tool call and result, confirmation requests, usage, and one done or error event at the end.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`attachments`required	`array of PioneerAttachmentBody`
`attachments[].data`required	`string`
`attachments[].mediaType`required	`string`
`attachments[].name`required	`string`
`attachments[].text`required	`string`
`mentions`required	`array of PioneerMentionBody`
`mentions[].clientId`required	`string`
`mentions[].id`required	`string`
`mentions[].kind`required	`string`
`page`	`PageContext`	PageContext is the page the user was on when they sent the message.
`page.entity`	`PageEntity`
`page.entity.id`required	`string`
`page.entity.kind`required	`string`
`page.path`required	`string`
`page.terminals`	`array of PageTerminal`
`page.terminals[].interpreter`	`string`
`page.terminals[].label`required	`string`
`page.terminals[].os`	`string`
`page.terminals[].tabId`required	`string`
`page.title`	`string`
`text`required	`string`
`tier`required	`string`
`timeZone`required	`string`

Responses

Status	Body	Description
`200`	`text/event-stream`, string	Success. The body shape was not resolved; see x-outpost-unresolved.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/messages' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/messages' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/messages"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "attachments": [
        {
            "data": "string",
            "mediaType": "string",
            "name": "string",
            "text": "string",
        },
    ],
    "mentions": [
        {
            "clientId": "string",
            "id": "string",
            "kind": "string",
        },
    ],
    "page": {
        "entity": {
            "id": "string",
            "kind": "string",
        },
        "path": "string",
        "terminals": [
            {
                "interpreter": "string",
                "label": "string",
                "os": "string",
                "tabId": "string",
            },
        ],
        "title": "string",
    },
    "text": "string",
    "tier": "string",
    "timeZone": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/messages", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/messages";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "attachments": [
      {
        "data": "string",
        "mediaType": "string",
        "name": "string",
        "text": "string"
      }
    ],
    "mentions": [
      {
        "clientId": "string",
        "id": "string",
        "kind": "string"
      }
    ],
    "page": {
      "entity": {
        "id": "string",
        "kind": "string"
      },
      "path": "string",
      "terminals": [
        {
          "interpreter": "string",
          "label": "string",
          "os": "string",
          "tabId": "string"
        }
      ],
      "title": "string"
    },
    "text": "string",
    "tier": "string",
    "timeZone": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/messages");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PUT `/api/v1/ai/conversations/{id}/messages/{seq}/feedback`

PUTai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

putFeedback rates one of Pioneer’s replies, replacing an earlier rating.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes
`seq`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`note`required	`string`
`rating`	`integer or null`

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not save the feedback.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X PUT 'https://depot.example.com/api/v1/ai/conversations/<id>/messages/<seq>/feedback' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "note": "string",
  "rating": 0
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "note": "string",
  "rating": 0
}
'@

$response = Invoke-RestMethod `
    -Method Put `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/messages/<seq>/feedback' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/messages/<seq>/feedback"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "note": "string",
    "rating": 0,
}

response = requests.put(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "note": "string",
  "rating": 0
}`)

  req, err := http.NewRequest(http.MethodPut, "https://depot.example.com/api/v1/ai/conversations/<id>/messages/<seq>/feedback", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/messages/<seq>/feedback";

const response = await fetch(url, {
  method: "PUT",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "note": "string",
    "rating": 0
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "note": "string",
  "rating": 0
}
""";

var request = new HttpRequestMessage(HttpMethod.Put, "https://depot.example.com/api/v1/ai/conversations/<id>/messages/<seq>/feedback");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}/queue`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

listQueuedInputs lists the input still waiting for Pioneer to read, oldest first.

Input left when a turn ended without reading it stays here until it is sent as a message or removed.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not read the queued messages.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>/queue' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/queue' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/queue"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>/queue", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/queue";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>/queue");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/queue`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

queueInput adds input for Pioneer to read at its next step, while it is working on a turn.

It takes the body POST /messages does (page, tier and timeZone are the running turn’s and are ignored) and is checked the same way. Answers 202 with the queued input; 409 not_running or awaiting_approval when no turn is running to take it.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`attachments`required	`array of PioneerAttachmentBody`
`attachments[].data`required	`string`
`attachments[].mediaType`required	`string`
`attachments[].name`required	`string`
`attachments[].text`required	`string`
`mentions`required	`array of PioneerMentionBody`
`mentions[].clientId`required	`string`
`mentions[].id`required	`string`
`mentions[].kind`required	`string`
`page`	`PageContext`	PageContext is the page the user was on when they sent the message.
`page.entity`	`PageEntity`
`page.entity.id`required	`string`
`page.entity.kind`required	`string`
`page.path`required	`string`
`page.terminals`	`array of PageTerminal`
`page.terminals[].interpreter`	`string`
`page.terminals[].label`required	`string`
`page.terminals[].os`	`string`
`page.terminals[].tabId`required	`string`
`page.title`	`string`
`text`required	`string`
`tier`required	`string`
`timeZone`required	`string`

Responses

Status	Body	Description
`202`	`application/json`, PioneerQueuedView	Accepted.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

202 response body

Field	Type	Description
`attachmentErrors`	`array of AttachmentErrorData`
`attachmentErrors[].message`required	`string`
`attachmentErrors[].name`required	`string`
`attachments`	`array of AttachmentMeta`
`attachments[].kind`required	`string, one of diagram, image, text`
`attachments[].mediaType`required	`string`
`attachments[].name`required	`string`
`attachments[].size`required	`integer`
`createdAt`required	`string (date-time)`
`id`required	`string`
`mentions`	`array of MentionMeta`
`mentions[].kind`required	`string`
`mentions[].name`required	`string`
`text`required	`string`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/queue' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/queue' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/queue"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "attachments": [
        {
            "data": "string",
            "mediaType": "string",
            "name": "string",
            "text": "string",
        },
    ],
    "mentions": [
        {
            "clientId": "string",
            "id": "string",
            "kind": "string",
        },
    ],
    "page": {
        "entity": {
            "id": "string",
            "kind": "string",
        },
        "path": "string",
        "terminals": [
            {
                "interpreter": "string",
                "label": "string",
                "os": "string",
                "tabId": "string",
            },
        ],
        "title": "string",
    },
    "text": "string",
    "tier": "string",
    "timeZone": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/queue", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/queue";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "attachments": [
      {
        "data": "string",
        "mediaType": "string",
        "name": "string",
        "text": "string"
      }
    ],
    "mentions": [
      {
        "clientId": "string",
        "id": "string",
        "kind": "string"
      }
    ],
    "page": {
      "entity": {
        "id": "string",
        "kind": "string"
      },
      "path": "string",
      "terminals": [
        {
          "interpreter": "string",
          "label": "string",
          "os": "string",
          "tabId": "string"
        }
      ],
      "title": "string"
    },
    "text": "string",
    "tier": "string",
    "timeZone": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/queue");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE `/api/v1/ai/conversations/{id}/queue/{queuedId}`

DELETEai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

deleteQueuedInput removes input before Pioneer reads it.

Answers 404 once Pioneer has taken it.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes
`queuedId`	path	string	Yes

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not remove the queued message.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X DELETE 'https://depot.example.com/api/v1/ai/conversations/<id>/queue/<queuedId>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Delete `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/queue/<queuedId>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/queue/<queuedId>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.delete(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodDelete, "https://depot.example.com/api/v1/ai/conversations/<id>/queue/<queuedId>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/queue/<queuedId>";

const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "https://depot.example.com/api/v1/ai/conversations/<id>/queue/<queuedId>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/resume`

POSTshared facehosteditmspremoteServer sent eventsNot fully resolved

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

What this page does not know

response

These are parts of the route the extractor could not read from the source. Everything else on this page came straight from it.

Source: [object Object]

resumeConversation continues a conversation: it re-runs the action that was waiting for approval, with the same arguments, or picks up a turn that was interrupted.

Streams like messages.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`attachments`required	`array of PioneerAttachmentBody`
`attachments[].data`required	`string`
`attachments[].mediaType`required	`string`
`attachments[].name`required	`string`
`attachments[].text`required	`string`
`mentions`required	`array of PioneerMentionBody`
`mentions[].clientId`required	`string`
`mentions[].id`required	`string`
`mentions[].kind`required	`string`
`page`	`PageContext`	PageContext is the page the user was on when they sent the message.
`page.entity`	`PageEntity`
`page.entity.id`required	`string`
`page.entity.kind`required	`string`
`page.path`required	`string`
`page.terminals`	`array of PageTerminal`
`page.terminals[].interpreter`	`string`
`page.terminals[].label`required	`string`
`page.terminals[].os`	`string`
`page.terminals[].tabId`required	`string`
`page.title`	`string`
`text`required	`string`
`tier`required	`string`
`timeZone`required	`string`

Responses

Status	Body	Description
`200`	`text/event-stream`, string	Success. The body shape was not resolved; see x-outpost-unresolved.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/resume' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/resume' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This endpoint streams server sent events. The response stays open.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/resume"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "attachments": [
        {
            "data": "string",
            "mediaType": "string",
            "name": "string",
            "text": "string",
        },
    ],
    "mentions": [
        {
            "clientId": "string",
            "id": "string",
            "kind": "string",
        },
    ],
    "page": {
        "entity": {
            "id": "string",
            "kind": "string",
        },
        "path": "string",
        "terminals": [
            {
                "interpreter": "string",
                "label": "string",
                "os": "string",
                "tabId": "string",
            },
        ],
        "title": "string",
    },
    "text": "string",
    "tier": "string",
    "timeZone": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/resume", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/resume";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "attachments": [
      {
        "data": "string",
        "mediaType": "string",
        "name": "string",
        "text": "string"
      }
    ],
    "mentions": [
      {
        "clientId": "string",
        "id": "string",
        "kind": "string"
      }
    ],
    "page": {
      "entity": {
        "id": "string",
        "kind": "string"
      },
      "path": "string",
      "terminals": [
        {
          "interpreter": "string",
          "label": "string",
          "os": "string",
          "tabId": "string"
        }
      ],
      "title": "string"
    },
    "text": "string",
    "tier": "string",
    "timeZone": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This endpoint streams server sent events. The response stays open.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "attachments": [
    {
      "data": "string",
      "mediaType": "string",
      "name": "string",
      "text": "string"
    }
  ],
  "mentions": [
    {
      "clientId": "string",
      "id": "string",
      "kind": "string"
    }
  ],
  "page": {
    "entity": {
      "id": "string",
      "kind": "string"
    },
    "path": "string",
    "terminals": [
      {
        "interpreter": "string",
        "label": "string",
        "os": "string",
        "tabId": "string"
      }
    ],
    "title": "string"
  },
  "text": "string",
  "tier": "string",
  "timeZone": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/resume");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/rewind`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

rewindConversation deletes the messages from beforeSeq on.

beforeSeq must be one of the user’s messages, so the transcript stays well formed.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`beforeSeq`	`integer or null`

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not rewind the conversation.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/rewind' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "beforeSeq": 0
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "beforeSeq": 0
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/rewind' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/rewind"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "beforeSeq": 0,
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "beforeSeq": 0
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/rewind", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/rewind";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "beforeSeq": 0
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "beforeSeq": 0
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/rewind");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/shells/{shellId}/input`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

shellInput types the technician’s keystrokes into Pioneer’s shell and holds it for them: shell_send is refused until Hand back or 10 minutes without input.

data is written unchanged.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes
`shellId`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`data`required	`string`

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/input' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "data": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "data": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/input' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/input"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "data": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "data": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/input", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/input";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "data": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "data": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/input");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}/shells/{shellId}/output`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

shellOutput returns the shell’s output events after the after seq, from its kept history, for the viewer to poll while no turn streams.

Parameters

Name	In	Type	Required
`id`	path	string	Yes
`shellId`	path	string	Yes
`after`	query	string	No

Responses

Status	Body	Description
`200`	`application/json`, ShellOutputView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`events`required	`array of ShellOutputData`
`events[].agentId`required	`string`
`events[].clientId`	`string`
`events[].closed`	`boolean`
`events[].data`required	`string`
`events[].seq`required	`integer`
`events[].shellId`required	`string`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/output?after=<after>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/output?after=<after>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/output"
params = {
    "after": "<after>",
}
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, params=params, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/output?after=<after>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = new URL("https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/output");
url.searchParams.set("after", "<after>");

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/output?after=<after>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/shells/{shellId}/release`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

releaseShell hands the shell back to Pioneer (or the tab closed).

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes
`shellId`	path	string	Yes

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/release' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/release' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/release"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.post(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/release", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/release";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/shells/<shellId>/release");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/stop`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

stopConversation asks the running turn to stop after the step in progress.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`interruptShells`required	`boolean`

Responses

Status	Body	Description
`202`	None	Accepted.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	Could not stop the conversation.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/stop' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "interruptShells": false
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "interruptShells": false
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/stop' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/stop"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "interruptShells": False,
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "interruptShells": false
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/stop", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/stop";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "interruptShells": false
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "interruptShells": false
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/stop");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/summary`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

summarizeConversation writes a ticket-ready internal note of the conversation: findings, actions taken and next steps.

It is returned, not saved.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/summary' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/summary' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/summary"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.post(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/summary", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/summary";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/summary");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/conversations/{id}/trace`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

getTrace returns a conversation’s steps in order: each model call, tool call and web search, with its tier, confirmation, classifier verdict, duration, tokens and cost.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/conversations/<id>/trace' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/trace' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/trace"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/conversations/<id>/trace", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/trace";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/conversations/<id>/trace");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/conversations/{id}/undo/{toolUseId}`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

undoAction reverses one of the conversation’s tool calls.

A write runs now; a high-impact reversal answers 202 with an approval to decide in the console, after which posting again runs it. A call is undone once.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes
`toolUseId`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`202`	`application/json`, PioneerUndoApprovalView	Accepted.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such conversation.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/conversations/<id>/undo/<toolUseId>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/conversations/<id>/undo/<toolUseId>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/conversations/<id>/undo/<toolUseId>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.post(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/conversations/<id>/undo/<toolUseId>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/conversations/<id>/undo/<toolUseId>";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/conversations/<id>/undo/<toolUseId>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/drive/{requestId}/result`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

driveResult takes the technician’s viewer’s answer to one screen request: the screenshot after the action, or why there is none.

A request that is not the caller’s answers 404, exactly like one that does not exist.

Parameters

Name	In	Type	Required	Description
`requestId`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`closed`required	`boolean`
`error`required	`string`
`height`	`integer or null`
`image`required	`string`
`output`	`string or null`
`secure`required	`boolean`
`takeover`required	`boolean`
`width`	`integer or null`

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such screen request.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/drive/<requestId>/result' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "closed": false,
  "error": "string",
  "height": 0,
  "image": "string",
  "output": "string",
  "secure": false,
  "takeover": false,
  "width": 0
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "closed": false,
  "error": "string",
  "height": 0,
  "image": "string",
  "output": "string",
  "secure": false,
  "takeover": false,
  "width": 0
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/drive/<requestId>/result' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/drive/<requestId>/result"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "closed": False,
    "error": "string",
    "height": 0,
    "image": "string",
    "output": "string",
    "secure": False,
    "takeover": False,
    "width": 0,
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "closed": false,
  "error": "string",
  "height": 0,
  "image": "string",
  "output": "string",
  "secure": false,
  "takeover": false,
  "width": 0
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/drive/<requestId>/result", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/drive/<requestId>/result";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "closed": false,
    "error": "string",
    "height": 0,
    "image": "string",
    "output": "string",
    "secure": false,
    "takeover": false,
    "width": 0
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "closed": false,
  "error": "string",
  "height": 0,
  "image": "string",
  "output": "string",
  "secure": false,
  "takeover": false,
  "width": 0
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/drive/<requestId>/result");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/memories`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

listMemories returns your personal Pioneer memories plus the organization’s and those of the clients you can see, newest first.

scope and clientId narrow the list.

Parameters

Name	In	Type	Required	Description
`clientId`	query	string	No
`scope`	query	string	No

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such client.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/memories?clientId=<clientId>&scope=<scope>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/memories?clientId=<clientId>&scope=<scope>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/memories"
params = {
    "clientId": "<clientId>",
    "scope": "<scope>",
}
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, params=params, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/memories?clientId=<clientId>&scope=<scope>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = new URL("https://depot.example.com/api/v1/ai/memories");
url.searchParams.set("clientId", "<clientId>");
url.searchParams.set("scope", "<scope>");

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/memories?clientId=<clientId>&scope=<scope>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/memories`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

createMemory saves a Pioneer memory from a proposal card or the settings page.

An org memory needs ai:manage; a client memory needs access to that client.

Request body

Required, sent as application/json.

Field	Type	Description
`clientId`required	`string`
`conversationId`required	`string`
`pinned`required	`boolean`
`scope`required	`string`
`source`required	`string`
`text`required	`string`

Responses

Status	Body	Description
`201`	`application/json`, PioneerMemoryView	Created.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such memory.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

201 response body

Field	Type	Description
`clientId`	`string or null`
`clientName`	`string or null`
`createdAt`required	`string (date-time)`
`createdByUserId`	`string or null`
`id`required	`string`
`pinned`required	`boolean`
`scope`required	`string`
`source`required	`string`
`sourceConversationId`	`string or null`
`text`required	`string`
`updatedAt`required	`string (date-time)`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/memories' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "clientId": "string",
  "conversationId": "string",
  "pinned": false,
  "scope": "string",
  "source": "string",
  "text": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "clientId": "string",
  "conversationId": "string",
  "pinned": false,
  "scope": "string",
  "source": "string",
  "text": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/memories' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/memories"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "clientId": "string",
    "conversationId": "string",
    "pinned": False,
    "scope": "string",
    "source": "string",
    "text": "string",
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "clientId": "string",
  "conversationId": "string",
  "pinned": false,
  "scope": "string",
  "source": "string",
  "text": "string"
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/memories", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/memories";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "clientId": "string",
    "conversationId": "string",
    "pinned": false,
    "scope": "string",
    "source": "string",
    "text": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "clientId": "string",
  "conversationId": "string",
  "pinned": false,
  "scope": "string",
  "source": "string",
  "text": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/memories");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH `/api/v1/ai/memories/{id}`

PATCHai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

updateMemory changes a memory’s text or pin.

Your personal memories are yours to change; shared ones need ai:manage.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`pinned`	`boolean or null`
`text`	`string or null`

Responses

Status	Body	Description
`200`	`application/json`, PioneerMemoryView	Success.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such memory.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`clientId`	`string or null`
`clientName`	`string or null`
`createdAt`required	`string (date-time)`
`createdByUserId`	`string or null`
`id`required	`string`
`pinned`required	`boolean`
`scope`required	`string`
`source`required	`string`
`sourceConversationId`	`string or null`
`text`required	`string`
`updatedAt`required	`string (date-time)`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X PATCH 'https://depot.example.com/api/v1/ai/memories/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "pinned": false,
  "text": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "pinned": false,
  "text": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Patch `
    -Uri 'https://depot.example.com/api/v1/ai/memories/<id>' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/memories/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "pinned": False,
    "text": "string",
}

response = requests.patch(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "pinned": false,
  "text": "string"
}`)

  req, err := http.NewRequest(http.MethodPatch, "https://depot.example.com/api/v1/ai/memories/<id>", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/memories/<id>";

const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "pinned": false,
    "text": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "pinned": false,
  "text": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Patch, "https://depot.example.com/api/v1/ai/memories/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE `/api/v1/ai/memories/{id}`

DELETEai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

deleteMemory deletes a memory.

Your personal memories are yours to delete; shared ones need ai:manage.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such memory.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X DELETE 'https://depot.example.com/api/v1/ai/memories/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Delete `
    -Uri 'https://depot.example.com/api/v1/ai/memories/<id>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/memories/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.delete(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodDelete, "https://depot.example.com/api/v1/ai/memories/<id>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/memories/<id>";

const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "https://depot.example.com/api/v1/ai/memories/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/prompts`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

listPrompts returns your saved Pioneer prompts and the shared ones.

Responses

Status	Body	Description
`200`	`application/json`, array of PioneerPromptView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`[].body`required	`string`
`[].command`required	`string`
`[].createdAt`required	`string (date-time)`
`[].id`required	`string`
`[].name`required	`string`
`[].ownerUserId`	`string or null`
`[].shared`required	`boolean`
`[].updatedAt`required	`string (date-time)`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/prompts' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/prompts' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/prompts"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/prompts", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/prompts";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/prompts");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/ai/prompts`

POSTai:useshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

createPrompt saves a prompt.

shared makes it the organization’s, which needs ai:manage.

Request body

Required, sent as application/json.

Field	Type	Description
`body`	`string or null`
`command`	`string or null`
`name`	`string or null`
`shared`required	`boolean`

Responses

Status	Body	Description
`201`	`application/json`, PioneerPromptView	Created.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such user.
`409`	`application/problem+json`, ProblemDetails	A prompt with this command already exists.
`500`	`application/problem+json`, ProblemDetails	Could not save the prompt.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

201 response body

Field	Type	Description
`body`required	`string`
`command`required	`string`
`createdAt`required	`string (date-time)`
`id`required	`string`
`name`required	`string`
`ownerUserId`	`string or null`
`shared`required	`boolean`
`updatedAt`required	`string (date-time)`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/ai/prompts' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}
'@

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/ai/prompts' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/ai/prompts"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "body": "string",
    "command": "string",
    "name": "string",
    "shared": False,
}

response = requests.post(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}`)

  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/ai/prompts", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/prompts";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "body": "string",
    "command": "string",
    "name": "string",
    "shared": false
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}
""";

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/ai/prompts");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH `/api/v1/ai/prompts/{id}`

PATCHai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

updatePrompt changes a prompt’s command, name or body.

Whether it is shared cannot change.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`body`	`string or null`
`command`	`string or null`
`name`	`string or null`
`shared`required	`boolean`

Responses

Status	Body	Description
`200`	`application/json`, PioneerPromptView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such prompt.
`409`	`application/problem+json`, ProblemDetails	A prompt with this command already exists.
`500`	`application/problem+json`, ProblemDetails	Could not save the prompt.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`body`required	`string`
`command`required	`string`
`createdAt`required	`string (date-time)`
`id`required	`string`
`name`required	`string`
`ownerUserId`	`string or null`
`shared`required	`boolean`
`updatedAt`required	`string (date-time)`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X PATCH 'https://depot.example.com/api/v1/ai/prompts/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}
'@

$response = Invoke-RestMethod `
    -Method Patch `
    -Uri 'https://depot.example.com/api/v1/ai/prompts/<id>' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/prompts/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "body": "string",
    "command": "string",
    "name": "string",
    "shared": False,
}

response = requests.patch(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}`)

  req, err := http.NewRequest(http.MethodPatch, "https://depot.example.com/api/v1/ai/prompts/<id>", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/prompts/<id>";

const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "body": "string",
    "command": "string",
    "name": "string",
    "shared": false
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "body": "string",
  "command": "string",
  "name": "string",
  "shared": false
}
""";

var request = new HttpRequestMessage(HttpMethod.Patch, "https://depot.example.com/api/v1/ai/prompts/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE `/api/v1/ai/prompts/{id}`

DELETEai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

deletePrompt deletes one of your prompts, or a shared one with ai:manage.

Parameters

Name	In	Type	Required	Description
`id`	path	string	Yes

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such prompt.
`500`	`application/problem+json`, ProblemDetails	Could not delete the prompt.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X DELETE 'https://depot.example.com/api/v1/ai/prompts/<id>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Delete `
    -Uri 'https://depot.example.com/api/v1/ai/prompts/<id>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/prompts/<id>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.delete(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodDelete, "https://depot.example.com/api/v1/ai/prompts/<id>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/prompts/<id>";

const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "https://depot.example.com/api/v1/ai/prompts/<id>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/unseen`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

unseen returns how many of your conversations have a background result you have not opened yet.

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/unseen' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/unseen' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/unseen"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/unseen", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/unseen";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/unseen");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/ai/usage/me`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

My usage

Responses

Status	Body	Description
`200`	`application/json`, AiMyUsageView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`exhausted`required	`boolean`
`limitMicroCents`required	`integer`	int64.
`limited`required	`boolean`
`limitedBy`required	`string`
`metered`required	`boolean`
`mode`required	`string`
`remainingMicroCents`required	`integer`	int64.
`resetsAt`required	`string (date-time)`
`source`required	`string`
`spentMicroCents`required	`integer`	int64.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/ai/usage/me' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/ai/usage/me' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/ai/usage/me"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/ai/usage/me", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/ai/usage/me";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/ai/usage/me");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/clients/{clientID}/ai-override`

GETclient:readmsp facemspIdempotent

Source: [object Object]

getOverride returns a client’s Pioneer AI override, the MSP policy it overrides, and the client’s own Pioneer instructions and classifier policy.

Parameters

Name	In	Type	Required	Description
`clientID`	path	string	Yes

Responses

Status	Body	Description
`200`	`application/json`, AiOverrideView	Success.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold client:read.
`404`	`application/problem+json`, ProblemDetails	No such client.
`500`	`application/problem+json`, ProblemDetails	Could not read the client.
`503`	`application/problem+json`, ProblemDetails	This Depot has no practice database to read the AI policy from yet.

200 response body

Field	Type	Description
`effective`required	`boolean`
`override`required	`string`
`permitted`required	`boolean`
`pioneerClassifierPolicy`	`string or null`
`pioneerInstructions`	`string or null`
`policy`required	`string`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/clients/<clientID>/ai-override' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/clients/<clientID>/ai-override' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/clients/<clientID>/ai-override"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/clients/<clientID>/ai-override", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/clients/<clientID>/ai-override";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/clients/<clientID>/ai-override");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PUT `/api/v1/clients/{clientID}/ai-override`

PUTai:managemsp facemspIdempotent

Source: [object Object]

Put override

Parameters

Name	In	Type	Required	Description
`clientID`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`override`required	`string`
`pioneerClassifierPolicy`	`string or null`
`pioneerInstructions`	`string or null`

Responses

Status	Body	Description
`200`	`application/json`, AiOverrideView	Success.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No such client.
`500`	`application/problem+json`, ProblemDetails	Could not read the client.
`503`	`application/problem+json`, ProblemDetails	This Depot has no practice database to read the AI policy from yet.

200 response body

Field	Type	Description
`effective`required	`boolean`
`override`required	`string`
`permitted`required	`boolean`
`pioneerClassifierPolicy`	`string or null`
`pioneerInstructions`	`string or null`
`policy`required	`string`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X PUT 'https://depot.example.com/api/v1/clients/<clientID>/ai-override' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "override": "string",
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "override": "string",
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Put `
    -Uri 'https://depot.example.com/api/v1/clients/<clientID>/ai-override' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/clients/<clientID>/ai-override"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "override": "string",
    "pioneerClassifierPolicy": "string",
    "pioneerInstructions": "string",
}

response = requests.put(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "override": "string",
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string"
}`)

  req, err := http.NewRequest(http.MethodPut, "https://depot.example.com/api/v1/clients/<clientID>/ai-override", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/clients/<clientID>/ai-override";

const response = await fetch(url, {
  method: "PUT",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "override": "string",
    "pioneerClassifierPolicy": "string",
    "pioneerInstructions": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "override": "string",
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Put, "https://depot.example.com/api/v1/clients/<clientID>/ai-override");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PUT `/api/v1/console/me/ai-auto-approve`

PUTai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

putAutoApprove turns your own “let Pioneer auto-approve actions” opt-in on or off.

On, a separate AI safety review may approve an action your permissions allow in place of you, within the ceiling an owner set. Turning it on needs the owner’s mode on and the server to allow it, and a fresh step-up when the mode covers high-impact actions. Turning it off always works.

Request body

Required, sent as application/json.

Field	Type	Description
`enabled`	`boolean or null`

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No such user.
`500`	`application/problem+json`, ProblemDetails	Could not save auto-approve.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X PUT 'https://depot.example.com/api/v1/console/me/ai-auto-approve' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "enabled": false
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "enabled": false
}
'@

$response = Invoke-RestMethod `
    -Method Put `
    -Uri 'https://depot.example.com/api/v1/console/me/ai-auto-approve' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/console/me/ai-auto-approve"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "enabled": False,
}

response = requests.put(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "enabled": false
}`)

  req, err := http.NewRequest(http.MethodPut, "https://depot.example.com/api/v1/console/me/ai-auto-approve", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/console/me/ai-auto-approve";

const response = await fetch(url, {
  method: "PUT",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "enabled": false
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "enabled": false
}
""";

var request = new HttpRequestMessage(HttpMethod.Put, "https://depot.example.com/api/v1/console/me/ai-auto-approve");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/organization/ai/budgets`

GETai:manageshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

listBudgets is every console user with their month-to-date spend and override, plus anyone the ledger or an override names who is not one.

Responses

Status	Body	Description
`200`	`application/json`, AiBudgetsView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`globalBudgetMicroCents`	`integer or null`	int64.
`globalSpentMicroCents`required	`integer`	int64.
`members`required	`array of AiMemberBudgetView`
`members[].calls`required	`integer`	int64.
`members[].displayName`required	`string`
`members[].email`required	`string`
`members[].override`	`AiOverrideBudgetView`
`members[].override.mode`required	`string`
`members[].override.monthlyBudgetMicroCents`required	`integer`	int64.
`members[].override.updatedAt`required	`string (date-time)`
`members[].refused`required	`integer`	int64.
`members[].spentMicroCents`required	`integer`	int64.
`members[].status`required	`string`
`members[].userId`required	`string`
`monthStart`required	`string (date-time)`
`priced`required	`boolean`
`resetsAt`required	`string (date-time)`
`source`required	`string`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/organization/ai/budgets' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/organization/ai/budgets' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/budgets"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/organization/ai/budgets", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/budgets";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/organization/ai/budgets");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PUT `/api/v1/organization/ai/budgets/{userID}`

PUTai:manageshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

Put budget

Parameters

Name	In	Type	Required	Description
`userID`	path	string	Yes

Request body

Required, sent as application/json.

Field	Type	Description
`mode`required	`string`
`monthlyBudgetMicroCents`	`integer or null`	int64.

Responses

Status	Body	Description
`200`	`application/json`, AiOverrideBudgetView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No such team member.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`mode`required	`string`
`monthlyBudgetMicroCents`required	`integer`	int64.
`updatedAt`required	`string (date-time)`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X PUT 'https://depot.example.com/api/v1/organization/ai/budgets/<userID>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "mode": "string",
  "monthlyBudgetMicroCents": 0
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "mode": "string",
  "monthlyBudgetMicroCents": 0
}
'@

$response = Invoke-RestMethod `
    -Method Put `
    -Uri 'https://depot.example.com/api/v1/organization/ai/budgets/<userID>' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/budgets/<userID>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "mode": "string",
    "monthlyBudgetMicroCents": 0,
}

response = requests.put(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "mode": "string",
  "monthlyBudgetMicroCents": 0
}`)

  req, err := http.NewRequest(http.MethodPut, "https://depot.example.com/api/v1/organization/ai/budgets/<userID>", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/budgets/<userID>";

const response = await fetch(url, {
  method: "PUT",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "mode": "string",
    "monthlyBudgetMicroCents": 0
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "mode": "string",
  "monthlyBudgetMicroCents": 0
}
""";

var request = new HttpRequestMessage(HttpMethod.Put, "https://depot.example.com/api/v1/organization/ai/budgets/<userID>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE `/api/v1/organization/ai/budgets/{userID}`

DELETEai:manageshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

Delete budget

Parameters

Name	In	Type	Required	Description
`userID`	path	string	Yes

Responses

Status	Body	Description
`204`	None	Success, with no body.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No such team member.
`500`	`application/problem+json`, ProblemDetails	Could not remove the AI budget.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X DELETE 'https://depot.example.com/api/v1/organization/ai/budgets/<userID>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Delete `
    -Uri 'https://depot.example.com/api/v1/organization/ai/budgets/<userID>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/budgets/<userID>"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.delete(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodDelete, "https://depot.example.com/api/v1/organization/ai/budgets/<userID>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/budgets/<userID>";

const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "https://depot.example.com/api/v1/organization/ai/budgets/<userID>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/organization/ai/catalog`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

catalog passes Core’s catalog through, less the vision tier (no conversation runs on it), plus pioneerTiers (the tiers a conversation may pick) and attachments (what the composer may send; section 17).

Anywhere Outpost Cloud AI is not the source, or cannot be reached, the tier list is empty.

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`502`	`application/problem+json`, ProblemDetails	Could not reach Outpost Cloud AI. Please try again.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/organization/ai/catalog' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/organization/ai/catalog' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/catalog"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/organization/ai/catalog", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/catalog";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/organization/ai/catalog");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/organization/ai/settings`

GETai:useshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

Get settings

Responses

Status	Body	Description
`200`	`application/json`, AiSettingsView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:use.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`apiStyle`required	`string`
`baseUrl`required	`string`
`chatEnabled`required	`boolean`
`chatOn`required	`boolean`
`clientPolicy`	`string`
`cloudAllowed`required	`boolean`
`credentialsConfigured`required	`boolean`
`customCachedInputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customContextWindow`	`integer or null`
`customInputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customMaxOutputTokens`	`integer or null`
`customMonthlyBudgetMicroCents`	`integer or null`	int64.
`customOutputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customReasoningEffort`required	`string`
`customSearchKeyConfigured`required	`boolean`
`customSendPromptCacheKey`required	`boolean`
`customSendReasoningEffort`required	`boolean`
`customUsage`	`AiCustomUsage`	aiCustomUsage is the organization's month-to-date custom spend.
`customUsage.monthStart`required	`string (date-time)`
`customUsage.monthToDateMicroCents`required	`integer`	int64.
`customUsage.priced`required	`boolean`
`customUsage.resetsAt`required	`string (date-time)`
`defaultTier`required	`string`
`fastModel`required	`string`
`lastVerify`	`AiVerifyView`
`lastVerify.at`required	`string (date-time)`
`lastVerify.code`required	`string`
`lastVerify.message`required	`string`
`lastVerify.ok`required	`boolean`
`mcpEnabled`required	`boolean`
`mode`required	`string`
`model`required	`string`
`monthlyBudgetMicroCents`	`integer or null`	int64.
`outpostDocsAvailable`required	`boolean`
`pioneerAutoApprove`required	`string`
`pioneerAutoRunReadOnly`required	`boolean`
`pioneerClassifierPolicy`required	`string`
`pioneerInstructions`required	`string`
`pioneerOutpostDocs`required	`boolean`
`pioneerRetentionDays`required	`integer`
`pioneerSubagentAreas`required	`array of string`
`pioneerTurnCapMicroCents`required	`integer`	int64.
`pioneerWebSearch`required	`boolean`
`premiumModel`required	`string`
`proactiveEnabled`required	`boolean`
`source`required	`string`
`updatedAt`required	`string (date-time)`
`usable`required	`boolean`
`visionModel`required	`string`
`webSearchAvailable`required	`boolean`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/organization/ai/settings' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/organization/ai/settings' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/settings"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/organization/ai/settings", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/settings";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/organization/ai/settings");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

PUT `/api/v1/organization/ai/settings`

PUTai:manageshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

Put settings

Request body

Required, sent as application/json.

Field	Type	Description
`apiKey`required	`string`
`apiStyle`required	`string`
`baseUrl`required	`string`
`chatEnabled`	`boolean or null`
`clientPolicy`required	`string`
`customCachedInputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customContextWindow`required	`any`	Arbitrary JSON.
`customInputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customMaxOutputTokens`required	`any`	Arbitrary JSON.
`customMonthlyBudgetMicroCents`	`integer or null`	int64.
`customOutputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customReasoningEffort`	`string or null`
`customSearchKey`required	`string`
`customSendPromptCacheKey`	`boolean or null`
`customSendReasoningEffort`	`boolean or null`
`defaultTier`required	`string`
`fastModel`required	`string`
`mcpEnabled`	`boolean or null`
`model`required	`string`
`monthlyBudgetMicroCents`	`integer or null`	int64.
`pioneerAutoApprove`	`string or null`
`pioneerAutoRunReadOnly`	`boolean or null`
`pioneerClassifierPolicy`	`string or null`
`pioneerInstructions`	`string or null`
`pioneerOutpostDocs`	`boolean or null`
`pioneerRetentionDays`	`integer or null`
`pioneerSubagentAreas`required	`array of string`
`pioneerTurnCapMicroCents`	`integer or null`	int64.
`pioneerWebSearch`	`boolean or null`
`premiumModel`required	`string`
`proactiveEnabled`	`boolean or null`
`source`required	`string`
`visionModel`	`string or null`

Responses

Status	Body	Description
`200`	`application/json`, AiSettingsView	Success.
`400`	`application/problem+json`, ProblemDetails	The request body is not valid JSON.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`apiStyle`required	`string`
`baseUrl`required	`string`
`chatEnabled`required	`boolean`
`chatOn`required	`boolean`
`clientPolicy`	`string`
`cloudAllowed`required	`boolean`
`credentialsConfigured`required	`boolean`
`customCachedInputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customContextWindow`	`integer or null`
`customInputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customMaxOutputTokens`	`integer or null`
`customMonthlyBudgetMicroCents`	`integer or null`	int64.
`customOutputPriceMicroCentsPerMTok`	`integer or null`	int64.
`customReasoningEffort`required	`string`
`customSearchKeyConfigured`required	`boolean`
`customSendPromptCacheKey`required	`boolean`
`customSendReasoningEffort`required	`boolean`
`customUsage`	`AiCustomUsage`	aiCustomUsage is the organization's month-to-date custom spend.
`customUsage.monthStart`required	`string (date-time)`
`customUsage.monthToDateMicroCents`required	`integer`	int64.
`customUsage.priced`required	`boolean`
`customUsage.resetsAt`required	`string (date-time)`
`defaultTier`required	`string`
`fastModel`required	`string`
`lastVerify`	`AiVerifyView`
`lastVerify.at`required	`string (date-time)`
`lastVerify.code`required	`string`
`lastVerify.message`required	`string`
`lastVerify.ok`required	`boolean`
`mcpEnabled`required	`boolean`
`mode`required	`string`
`model`required	`string`
`monthlyBudgetMicroCents`	`integer or null`	int64.
`outpostDocsAvailable`required	`boolean`
`pioneerAutoApprove`required	`string`
`pioneerAutoRunReadOnly`required	`boolean`
`pioneerClassifierPolicy`required	`string`
`pioneerInstructions`required	`string`
`pioneerOutpostDocs`required	`boolean`
`pioneerRetentionDays`required	`integer`
`pioneerSubagentAreas`required	`array of string`
`pioneerTurnCapMicroCents`required	`integer`	int64.
`pioneerWebSearch`required	`boolean`
`premiumModel`required	`string`
`proactiveEnabled`required	`boolean`
`source`required	`string`
`updatedAt`required	`string (date-time)`
`usable`required	`boolean`
`visionModel`required	`string`
`webSearchAvailable`required	`boolean`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X PUT 'https://depot.example.com/api/v1/organization/ai/settings' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -b 'outpost_console=<console-session>' \
  --data '{
  "apiKey": "string",
  "apiStyle": "string",
  "baseUrl": "string",
  "chatEnabled": false,
  "clientPolicy": "string",
  "customCachedInputPriceMicroCentsPerMTok": 0,
  "customContextWindow": "string",
  "customInputPriceMicroCentsPerMTok": 0,
  "customMaxOutputTokens": "string",
  "customMonthlyBudgetMicroCents": 0,
  "customOutputPriceMicroCentsPerMTok": 0,
  "customReasoningEffort": "string",
  "customSearchKey": "string",
  "customSendPromptCacheKey": false,
  "customSendReasoningEffort": false,
  "defaultTier": "string",
  "fastModel": "string",
  "mcpEnabled": false,
  "model": "string",
  "monthlyBudgetMicroCents": 0,
  "pioneerAutoApprove": "string",
  "pioneerAutoRunReadOnly": false,
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string",
  "pioneerOutpostDocs": false,
  "pioneerRetentionDays": 0,
  "pioneerSubagentAreas": [
    "string"
  ],
  "pioneerTurnCapMicroCents": 0,
  "pioneerWebSearch": false,
  "premiumModel": "string",
  "proactiveEnabled": false,
  "source": "string",
  "visionModel": "string"
}'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Content-Type' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$body = @'
{
  "apiKey": "string",
  "apiStyle": "string",
  "baseUrl": "string",
  "chatEnabled": false,
  "clientPolicy": "string",
  "customCachedInputPriceMicroCentsPerMTok": 0,
  "customContextWindow": "string",
  "customInputPriceMicroCentsPerMTok": 0,
  "customMaxOutputTokens": "string",
  "customMonthlyBudgetMicroCents": 0,
  "customOutputPriceMicroCentsPerMTok": 0,
  "customReasoningEffort": "string",
  "customSearchKey": "string",
  "customSendPromptCacheKey": false,
  "customSendReasoningEffort": false,
  "defaultTier": "string",
  "fastModel": "string",
  "mcpEnabled": false,
  "model": "string",
  "monthlyBudgetMicroCents": 0,
  "pioneerAutoApprove": "string",
  "pioneerAutoRunReadOnly": false,
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string",
  "pioneerOutpostDocs": false,
  "pioneerRetentionDays": 0,
  "pioneerSubagentAreas": [
    "string"
  ],
  "pioneerTurnCapMicroCents": 0,
  "pioneerWebSearch": false,
  "premiumModel": "string",
  "proactiveEnabled": false,
  "source": "string",
  "visionModel": "string"
}
'@

$response = Invoke-RestMethod `
    -Method Put `
    -Uri 'https://depot.example.com/api/v1/organization/ai/settings' `
    -Headers $headers `
    -ContentType 'application/json' `
    -Body $body

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/settings"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}
payload = {
    "apiKey": "string",
    "apiStyle": "string",
    "baseUrl": "string",
    "chatEnabled": False,
    "clientPolicy": "string",
    "customCachedInputPriceMicroCentsPerMTok": 0,
    "customContextWindow": "string",
    "customInputPriceMicroCentsPerMTok": 0,
    "customMaxOutputTokens": "string",
    "customMonthlyBudgetMicroCents": 0,
    "customOutputPriceMicroCentsPerMTok": 0,
    "customReasoningEffort": "string",
    "customSearchKey": "string",
    "customSendPromptCacheKey": False,
    "customSendReasoningEffort": False,
    "defaultTier": "string",
    "fastModel": "string",
    "mcpEnabled": False,
    "model": "string",
    "monthlyBudgetMicroCents": 0,
    "pioneerAutoApprove": "string",
    "pioneerAutoRunReadOnly": False,
    "pioneerClassifierPolicy": "string",
    "pioneerInstructions": "string",
    "pioneerOutpostDocs": False,
    "pioneerRetentionDays": 0,
    "pioneerSubagentAreas": [
        "string",
    ],
    "pioneerTurnCapMicroCents": 0,
    "pioneerWebSearch": False,
    "premiumModel": "string",
    "proactiveEnabled": False,
    "source": "string",
    "visionModel": "string",
}

response = requests.put(url, headers=headers, cookies=cookies, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "bytes"
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  body := []byte(`{
  "apiKey": "string",
  "apiStyle": "string",
  "baseUrl": "string",
  "chatEnabled": false,
  "clientPolicy": "string",
  "customCachedInputPriceMicroCentsPerMTok": 0,
  "customContextWindow": "string",
  "customInputPriceMicroCentsPerMTok": 0,
  "customMaxOutputTokens": "string",
  "customMonthlyBudgetMicroCents": 0,
  "customOutputPriceMicroCentsPerMTok": 0,
  "customReasoningEffort": "string",
  "customSearchKey": "string",
  "customSendPromptCacheKey": false,
  "customSendReasoningEffort": false,
  "defaultTier": "string",
  "fastModel": "string",
  "mcpEnabled": false,
  "model": "string",
  "monthlyBudgetMicroCents": 0,
  "pioneerAutoApprove": "string",
  "pioneerAutoRunReadOnly": false,
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string",
  "pioneerOutpostDocs": false,
  "pioneerRetentionDays": 0,
  "pioneerSubagentAreas": [
    "string"
  ],
  "pioneerTurnCapMicroCents": 0,
  "pioneerWebSearch": false,
  "premiumModel": "string",
  "proactiveEnabled": false,
  "source": "string",
  "visionModel": "string"
}`)

  req, err := http.NewRequest(http.MethodPut, "https://depot.example.com/api/v1/organization/ai/settings", bytes.NewReader(body))
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.Header.Set("Content-Type", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/settings";

const response = await fetch(url, {
  method: "PUT",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
    "Content-Type": "application/json",
  },
  credentials: "include",
  body: JSON.stringify({
    "apiKey": "string",
    "apiStyle": "string",
    "baseUrl": "string",
    "chatEnabled": false,
    "clientPolicy": "string",
    "customCachedInputPriceMicroCentsPerMTok": 0,
    "customContextWindow": "string",
    "customInputPriceMicroCentsPerMTok": 0,
    "customMaxOutputTokens": "string",
    "customMonthlyBudgetMicroCents": 0,
    "customOutputPriceMicroCentsPerMTok": 0,
    "customReasoningEffort": "string",
    "customSearchKey": "string",
    "customSendPromptCacheKey": false,
    "customSendReasoningEffort": false,
    "defaultTier": "string",
    "fastModel": "string",
    "mcpEnabled": false,
    "model": "string",
    "monthlyBudgetMicroCents": 0,
    "pioneerAutoApprove": "string",
    "pioneerAutoRunReadOnly": false,
    "pioneerClassifierPolicy": "string",
    "pioneerInstructions": "string",
    "pioneerOutpostDocs": false,
    "pioneerRetentionDays": 0,
    "pioneerSubagentAreas": [
      "string"
    ],
    "pioneerTurnCapMicroCents": 0,
    "pioneerWebSearch": false,
    "premiumModel": "string",
    "proactiveEnabled": false,
    "source": "string",
    "visionModel": "string"
  }),
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;
using System.Text;

using var client = new HttpClient();

const string body = """
{
  "apiKey": "string",
  "apiStyle": "string",
  "baseUrl": "string",
  "chatEnabled": false,
  "clientPolicy": "string",
  "customCachedInputPriceMicroCentsPerMTok": 0,
  "customContextWindow": "string",
  "customInputPriceMicroCentsPerMTok": 0,
  "customMaxOutputTokens": "string",
  "customMonthlyBudgetMicroCents": 0,
  "customOutputPriceMicroCentsPerMTok": 0,
  "customReasoningEffort": "string",
  "customSearchKey": "string",
  "customSendPromptCacheKey": false,
  "customSendReasoningEffort": false,
  "defaultTier": "string",
  "fastModel": "string",
  "mcpEnabled": false,
  "model": "string",
  "monthlyBudgetMicroCents": 0,
  "pioneerAutoApprove": "string",
  "pioneerAutoRunReadOnly": false,
  "pioneerClassifierPolicy": "string",
  "pioneerInstructions": "string",
  "pioneerOutpostDocs": false,
  "pioneerRetentionDays": 0,
  "pioneerSubagentAreas": [
    "string"
  ],
  "pioneerTurnCapMicroCents": 0,
  "pioneerWebSearch": false,
  "premiumModel": "string",
  "proactiveEnabled": false,
  "source": "string",
  "visionModel": "string"
}
""";

var request = new HttpRequestMessage(HttpMethod.Put, "https://depot.example.com/api/v1/organization/ai/settings");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET `/api/v1/organization/ai/usage`

GETai:manageshared facehosteditmspremoteIdempotent

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

usageReport returns every AI call’s tokens and cost between from and to (default: this UTC month so far), grouped by user, feature, source, model or conversation.

Both sources are included: Outpost Cloud AI at Core’s price, your own endpoint at the prices set in Settings > AI.

Parameters

Name	In	Type	Required
`from`	query	string	No
`groupBy`	query	string	No
`to`	query	string	No

Responses

Status	Body	Description
`200`	`application/json`, object	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	Authentication is required.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.
curl -X GET 'https://depot.example.com/api/v1/organization/ai/usage?from=<from>&groupBy=<groupBy>&to=<to>' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Get `
    -Uri 'https://depot.example.com/api/v1/organization/ai/usage?from=<from>&groupBy=<groupBy>&to=<to>' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.
# This operation is idempotent. Repeating it does not repeat its effect.

import requests

url = "https://depot.example.com/api/v1/organization/ai/usage"
params = {
    "from": "<from>",
    "groupBy": "<groupBy>",
    "to": "<to>",
}
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.get(url, params=params, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodGet, "https://depot.example.com/api/v1/organization/ai/usage?from=<from>&groupBy=<groupBy>&to=<to>", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.
// The session cookie is set by signing in. A script cannot set it itself.

const url = new URL("https://depot.example.com/api/v1/organization/ai/usage");
url.searchParams.set("from", "<from>");
url.searchParams.set("groupBy", "<groupBy>");
url.searchParams.set("to", "<to>");

const response = await fetch(url, {
  method: "GET",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.
// This operation is idempotent. Repeating it does not repeat its effect.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://depot.example.com/api/v1/organization/ai/usage?from=<from>&groupBy=<groupBy>&to=<to>");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST `/api/v1/organization/ai/verify`

POSTai:manageshared facehosteditmspremote

From an MSP console, prefix the path with /api/v1/clients/{clientID} to reach one client.

Source: [object Object]

verify runs the saved row (never the form) and records the outcome.

Always 200 with the probe result: a failure is the answer, not an error.

Responses

Status	Body	Description
`200`	`application/json`, VerifyView	Success.
`400`	`application/problem+json`, ProblemDetails	One or more validation errors occurred.
`401`	`application/problem+json`, ProblemDetails	No signed-in identity.
`403`	`application/problem+json`, ProblemDetails	The identity does not hold ai:manage.
`404`	`application/problem+json`, ProblemDetails	No resource matches.
`500`	`application/problem+json`, ProblemDetails	The request failed.
`503`	`application/problem+json`, ProblemDetails	This Depot has no client database for this request yet.

200 response body

Field	Type	Description
`code`	`string`
`contextWindowFilled`	`integer`
`latencyMs`required	`integer`	int64.
`message`	`string`
`model`required	`string`
`ok`required	`boolean`
`reply`required	`string`
`usage`required	`Usage`
`usage.cacheRead`required	`integer`	int64.
`usage.cacheWrite`required	`integer`	int64.
`usage.estimateMicroCents`	`integer`	int64.
`usage.estimated`required	`boolean`
`usage.input`required	`integer`	int64.
`usage.output`required	`integer`	int64.
`usage.reasoning`	`integer`	int64.
`vision`	`VisionProbe`	VisionProbe is the vision model's half of Verify (PIONEER_CONTRACTS.md 17).
`vision.code`	`string`
`vision.message`	`string`
`vision.model`required	`string`
`vision.ok`required	`boolean`

Request samples

# Sign in first. outpost_console is a session cookie, so send it with every request.
curl -X POST 'https://depot.example.com/api/v1/organization/ai/verify' \
  -H 'X-CSRF-Token: <csrf-token>' \
  -H 'Accept: application/json' \
  -b 'outpost_console=<console-session>'

# Sign in first. outpost_console is a session cookie, so send it with every request.

$headers = @{
    'X-CSRF-Token' = '<csrf-token>'
    'Accept' = 'application/json'
    'Cookie' = 'outpost_console=<console-session>'
}

$response = Invoke-RestMethod `
    -Method Post `
    -Uri 'https://depot.example.com/api/v1/organization/ai/verify' `
    -Headers $headers

$response | ConvertTo-Json -Depth 10

# Sign in first. outpost_console is a session cookie, so send it with every request.

import requests

url = "https://depot.example.com/api/v1/organization/ai/verify"
headers = {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
}
cookies = {
    "outpost_console": "<console-session>",
}

response = requests.post(url, headers=headers, cookies=cookies, timeout=30)
response.raise_for_status()
print(response.json())

// Sign in first. outpost_console is a session cookie, so send it with every request.
package main

import (
  "fmt"
  "io"
  "log"
  "net/http"
)

func main() {
  req, err := http.NewRequest(http.MethodPost, "https://depot.example.com/api/v1/organization/ai/verify", nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Set("X-CSRF-Token", "<csrf-token>")
  req.Header.Set("Accept", "application/json")
  req.AddCookie(&http.Cookie{Name: "outpost_console", Value: "<console-session>"})

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    log.Fatal(err)
  }
  defer resp.Body.Close()

  out, err := io.ReadAll(resp.Body)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Status, string(out))
}

// Sign in first. outpost_console is a session cookie, so send it with every request.
// The session cookie is set by signing in. A script cannot set it itself.

const url = "https://depot.example.com/api/v1/organization/ai/verify";

const response = await fetch(url, {
  method: "POST",
  headers: {
    "X-CSRF-Token": "<csrf-token>",
    "Accept": "application/json",
  },
  credentials: "include",
});

if (!response.ok) {
  throw new Error(`Request failed with status ${response.status}`);
}

const data = await response.json();
console.log(data);

// Sign in first. outpost_console is a session cookie, so send it with every request.

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "https://depot.example.com/api/v1/organization/ai/verify");
request.Headers.TryAddWithoutValidation("X-CSRF-Token", "<csrf-token>");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
request.Headers.TryAddWithoutValidation("Cookie", "outpost_console=<console-session>");

var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());

Content is licensed CC BY 4.0. Code samples are MIT. Outpost and the Outpost mark are trademarks of Outpost Business Solutions, PBC and are not covered by either license.

Depot aisettings

POST /api/v1/ai/chat

Request body

Responses

Request samples

GET /api/v1/ai/conversations

Parameters

Responses

Request samples

POST /api/v1/ai/conversations

Request body

Responses

Request samples

GET /api/v1/ai/conversations/{id}

Parameters

Responses

Request samples

PATCH /api/v1/ai/conversations/{id}

Parameters

Request body

Responses

Request samples

DELETE /api/v1/ai/conversations/{id}

Parameters

Responses

Request samples

GET /api/v1/ai/conversations/{id}/actions

Parameters

Responses

Request samples

GET /api/v1/ai/conversations/{id}/diagrams/{toolUseId}

Parameters

Responses

Request samples

GET /api/v1/ai/conversations/{id}/documents/{toolUseId}

Parameters

Responses

Request samples

POST /api/v1/ai/conversations/{id}/messages

Parameters

Request body

Responses

Request samples

PUT /api/v1/ai/conversations/{id}/messages/{seq}/feedback

Parameters

Request body

Responses

Request samples

GET /api/v1/ai/conversations/{id}/queue

Parameters

Responses

Request samples

POST /api/v1/ai/conversations/{id}/queue

Parameters

Request body

Responses

Request samples

DELETE /api/v1/ai/conversations/{id}/queue/{queuedId}

Parameters

Responses

Request samples

POST /api/v1/ai/conversations/{id}/resume

Parameters

Request body

Responses

Request samples

POST /api/v1/ai/conversations/{id}/rewind

Parameters

Request body

Responses

Request samples

POST /api/v1/ai/conversations/{id}/shells/{shellId}/input

Parameters

Request body

Responses

Request samples

GET /api/v1/ai/conversations/{id}/shells/{shellId}/output

Parameters

Responses

Request samples

POST `/api/v1/ai/chat`

GET `/api/v1/ai/conversations`

POST `/api/v1/ai/conversations`

GET `/api/v1/ai/conversations/{id}`

PATCH `/api/v1/ai/conversations/{id}`

DELETE `/api/v1/ai/conversations/{id}`

GET `/api/v1/ai/conversations/{id}/actions`

GET `/api/v1/ai/conversations/{id}/diagrams/{toolUseId}`

GET `/api/v1/ai/conversations/{id}/documents/{toolUseId}`

POST `/api/v1/ai/conversations/{id}/messages`

PUT `/api/v1/ai/conversations/{id}/messages/{seq}/feedback`

GET `/api/v1/ai/conversations/{id}/queue`

POST `/api/v1/ai/conversations/{id}/queue`

DELETE `/api/v1/ai/conversations/{id}/queue/{queuedId}`

POST `/api/v1/ai/conversations/{id}/resume`

POST `/api/v1/ai/conversations/{id}/rewind`

POST `/api/v1/ai/conversations/{id}/shells/{shellId}/input`

GET `/api/v1/ai/conversations/{id}/shells/{shellId}/output`

POST `/api/v1/ai/conversations/{id}/shells/{shellId}/release`

POST `/api/v1/ai/conversations/{id}/stop`

POST `/api/v1/ai/conversations/{id}/summary`

GET `/api/v1/ai/conversations/{id}/trace`

POST `/api/v1/ai/conversations/{id}/undo/{toolUseId}`

POST `/api/v1/ai/drive/{requestId}/result`

GET `/api/v1/ai/memories`

POST `/api/v1/ai/memories`

PATCH `/api/v1/ai/memories/{id}`

DELETE `/api/v1/ai/memories/{id}`

GET `/api/v1/ai/prompts`

POST `/api/v1/ai/prompts`

PATCH `/api/v1/ai/prompts/{id}`

DELETE `/api/v1/ai/prompts/{id}`

GET `/api/v1/ai/unseen`

GET `/api/v1/ai/usage/me`

GET `/api/v1/clients/{clientID}/ai-override`