Ship against the whole contract.

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
url = f"https://run.huggingbay.xyz/v1"
headers = {}
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1`;
const headers = {};
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/demo/task" \
  -H 'Content-Type: application/json' \
  --data "{\"task\":\"Classify support messages by intent\",\"examples\":[{\"input\":\"Cannot log in => access\"},{\"input\":\"Refund please => billing\"},{\"input\":\"Order is late => delivery\"},{\"input\":\"Account is ready => account\"},{\"input\":\"Item is broken => fulfillment\"}]}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
url = f"https://run.huggingbay.xyz/v1/demo/task"
headers = {'Content-Type': 'application/json'}
payload = {'task': 'Classify support messages by intent', 'examples': [{'input': 'Cannot log in => access'}, {'input': 'Refund please => billing'}, {'input': 'Order is late => delivery'}, {'input': 'Account is ready => account'}, {'input': 'Item is broken => fulfillment'}]}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/demo/task`;
const headers = {};
headers["Content-Type"] = "application/json";
const payload = {
  "task": "Classify support messages by intent",
  "examples": [
    {
      "input": "Cannot log in => access"
    },
    {
      "input": "Refund please => billing"
    },
    {
      "input": "Order is late => delivery"
    },
    {
      "input": "Account is ready => account"
    },
    {
      "input": "Item is broken => fulfillment"
    }
  ]
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/identity" \
  -H "Authorization: Bearer ${BAY_RUN_API_KEY:?set BAY_RUN_API_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_API_KEY"]
url = f"https://run.huggingbay.xyz/v1/identity"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/identity`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_API_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/keys/free"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
url = f"https://run.huggingbay.xyz/v1/keys/free"
headers = {}
response = requests.request("POST", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/keys/free`;
const headers = {};
const response = await fetch(url, { method: "POST", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X DELETE \
  "https://run.huggingbay.xyz/v1/keys/free/${FREE_KEY_ID:-bfk_00000000000000000000000000000000}" \
  -H "Authorization: Bearer ${BAY_RUN_FREE_KEY:?set BAY_RUN_FREE_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_FREE_KEY"]
url = f"https://run.huggingbay.xyz/v1/keys/free/{env('FREE_KEY_ID', 'bfk_00000000000000000000000000000000')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("DELETE", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/keys/free/${env("FREE_KEY_ID", "bfk_00000000000000000000000000000000")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_FREE_KEY}`;
const response = await fetch(url, { method: "DELETE", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/quickstart"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
url = f"https://run.huggingbay.xyz/v1/quickstart"
headers = {}
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/quickstart`;
const headers = {};
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/try"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
url = f"https://run.huggingbay.xyz/v1/try"
headers = {}
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/try`;
const headers = {};
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/chat/completions" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"model\":\"Qwen/Qwen3-4B\",\"messages\":[{\"role\":\"user\",\"content\":\"In one sentence, why verify AI receipts?\"}],\"max_tokens\":48,\"temperature\":0}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/chat/completions"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'model': 'Qwen/Qwen3-4B', 'messages': [{'role': 'user', 'content': 'In one sentence, why verify AI receipts?'}], 'max_tokens': 48, 'temperature': 0}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/chat/completions`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "model": "Qwen/Qwen3-4B",
  "messages": [
    {
      "role": "user",
      "content": "In one sentence, why verify AI receipts?"
    }
  ],
  "max_tokens": 48,
  "temperature": 0
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/classify" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"model\":\"distilbert/distilbert-base-uncased-finetuned-sst-2-english\",\"input\":[\"The setup was quick.\",\"The checkout is broken.\"],\"top_k\":2}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/classify"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'model': 'distilbert/distilbert-base-uncased-finetuned-sst-2-english', 'input': ['The setup was quick.', 'The checkout is broken.'], 'top_k': 2}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/classify`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "model": "distilbert/distilbert-base-uncased-finetuned-sst-2-english",
  "input": [
    "The setup was quick.",
    "The checkout is broken."
  ],
  "top_k": 2
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/document/extract" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"content\":\"title,owner\\nDeveloper portal,Bay Run\\nReceipts,Operators\\n\",\"mime_type\":\"text/csv\",\"filename\":\"developer-example.csv\",\"max_rows\":10}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/document/extract"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'content': 'title,owner\nDeveloper portal,Bay Run\nReceipts,Operators\n', 'mime_type': 'text/csv', 'filename': 'developer-example.csv', 'max_rows': 10}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/document/extract`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "content": "title,owner\nDeveloper portal,Bay Run\nReceipts,Operators\n",
  "mime_type": "text/csv",
  "filename": "developer-example.csv",
  "max_rows": 10
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/embeddings" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"model\":\"BAAI/bge-small-en-v1.5\",\"input\":[\"Bay Run returns verifiable specialist-model results.\"]}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/embeddings"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'model': 'BAAI/bge-small-en-v1.5', 'input': ['Bay Run returns verifiable specialist-model results.']}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/embeddings`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "model": "BAAI/bge-small-en-v1.5",
  "input": [
    "Bay Run returns verifiable specialist-model results."
  ]
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/pdf/extract" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"pdf_base64\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA2OCA+PgpzdHJlYW0KQlQgL0YxIDE0IFRmIDcyIDcyMCBUZCAoQmF5IFJ1biBkZXZlbG9wZXIgcG9ydGFsIGxpdmUgZXhhbXBsZSkgVGogRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNTkgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MjkKJSVFT0YK\",\"max_pages\":1,\"max_chars\":2000}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/pdf/extract"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'pdf_base64': 'JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA2OCA+PgpzdHJlYW0KQlQgL0YxIDE0IFRmIDcyIDcyMCBUZCAoQmF5IFJ1biBkZXZlbG9wZXIgcG9ydGFsIGxpdmUgZXhhbXBsZSkgVGogRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNTkgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MjkKJSVFT0YK', 'max_pages': 1, 'max_chars': 2000}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/pdf/extract`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "pdf_base64": "JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA2OCA+PgpzdHJlYW0KQlQgL0YxIDE0IFRmIDcyIDcyMCBUZCAoQmF5IFJ1biBkZXZlbG9wZXIgcG9ydGFsIGxpdmUgZXhhbXBsZSkgVGogRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNTkgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MjkKJSVFT0YK",
  "max_pages": 1,
  "max_chars": 2000
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

PDF_BASE64='JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA2OCA+PgpzdHJlYW0KQlQgL0YxIDE0IFRmIDcyIDcyMCBUZCAoQmF5IFJ1biBkZXZlbG9wZXIgcG9ydGFsIGxpdmUgZXhhbXBsZSkgVGogRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNTkgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MjkKJSVFT0YK'
printf '%s' "$PDF_BASE64" | base64 --decode > /tmp/bay-run-developer-example.pdf
curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/pdf/extract/upload" \
  -H 'Content-Type: application/pdf' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data-binary '@/tmp/bay-run-developer-example.pdf'

import os
import base64
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/pdf/extract/upload"
headers = {'Content-Type': 'application/pdf'}
headers["Authorization"] = f"Bearer {token}"
body = base64.b64decode('JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA2OCA+PgpzdHJlYW0KQlQgL0YxIDE0IFRmIDcyIDcyMCBUZCAoQmF5IFJ1biBkZXZlbG9wZXIgcG9ydGFsIGxpdmUgZXhhbXBsZSkgVGogRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNTkgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MjkKJSVFT0YK')
response = requests.request("POST", url, headers=headers, data=body, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/pdf/extract/upload`;
const headers = {};
headers["Content-Type"] = "application/pdf";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const body = Buffer.from("JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA2OCA+PgpzdHJlYW0KQlQgL0YxIDE0IFRmIDcyIDcyMCBUZCAoQmF5IFJ1biBkZXZlbG9wZXIgcG9ydGFsIGxpdmUgZXhhbXBsZSkgVGogRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNTkgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MjkKJSVFT0YK", "base64");
const response = await fetch(url, { method: "POST", headers, body });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/rag" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"query\":\"What does receipt verification prove?\",\"documents\":[\"Receipt verification checks stored hashes, route facts, and charge evidence.\",\"It does not prove answer truth or model-weight identity.\"],\"top_k\":2,\"answer\":false}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/rag"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'query': 'What does receipt verification prove?', 'documents': ['Receipt verification checks stored hashes, route facts, and charge evidence.', 'It does not prove answer truth or model-weight identity.'], 'top_k': 2, 'answer': False}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/rag`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "query": "What does receipt verification prove?",
  "documents": [
    "Receipt verification checks stored hashes, route facts, and charge evidence.",
    "It does not prove answer truth or model-weight identity."
  ],
  "top_k": 2,
  "answer": false
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/rerank" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"model\":\"cross-encoder/ms-marco-TinyBERT-L2-v2\",\"query\":\"How do I verify a receipt?\",\"documents\":[\"Call the receipt verification endpoint with the returned receipt.\",\"Warm models are listed by the status endpoint.\"],\"top_n\":2}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/rerank"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'model': 'cross-encoder/ms-marco-TinyBERT-L2-v2', 'query': 'How do I verify a receipt?', 'documents': ['Call the receipt verification endpoint with the returned receipt.', 'Warm models are listed by the status endpoint.'], 'top_n': 2}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/rerank`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "model": "cross-encoder/ms-marco-TinyBERT-L2-v2",
  "query": "How do I verify a receipt?",
  "documents": [
    "Call the receipt verification endpoint with the returned receipt.",
    "Warm models are listed by the status endpoint."
  ],
  "top_n": 2
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/summarize" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"text\":\"Bay Run routes a task to a bounded specialist. It returns route evidence and a receipt. The receipt can be checked without rerunning the task.\",\"max_sentences\":2}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/summarize"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'text': 'Bay Run routes a task to a bounded specialist. It returns route evidence and a receipt. The receipt can be checked without rerunning the task.', 'max_sentences': 2}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/summarize`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "text": "Bay Run routes a task to a bounded specialist. It returns route evidence and a receipt. The receipt can be checked without rerunning the task.",
  "max_sentences": 2
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/bakeoff" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_API_KEY:?set BAY_RUN_API_KEY}" \
  --data "{\"task_description\":\"Classify customer feedback by sentiment\",\"examples\":[{\"input\":\"Setup works perfectly.\",\"expected\":\"positive\"},{\"input\":\"Checkout is broken.\",\"expected\":\"negative\"},{\"input\":\"Search feels fast.\",\"expected\":\"positive\"}],\"public\":false}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_API_KEY"]
url = f"https://run.huggingbay.xyz/v1/bakeoff"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task_description': 'Classify customer feedback by sentiment', 'examples': [{'input': 'Setup works perfectly.', 'expected': 'positive'}, {'input': 'Checkout is broken.', 'expected': 'negative'}, {'input': 'Search feels fast.', 'expected': 'positive'}], 'public': False}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/bakeoff`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_API_KEY}`;
const payload = {
  "task_description": "Classify customer feedback by sentiment",
  "examples": [
    {
      "input": "Setup works perfectly.",
      "expected": "positive"
    },
    {
      "input": "Checkout is broken.",
      "expected": "negative"
    },
    {
      "input": "Search feels fast.",
      "expected": "positive"
    }
  ],
  "public": false
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/bakeoffs/${BAKEOFF_ID:-bo_00000000000000000000000000000000}/claim" \
  -H 'Content-Type: application/json' \
  --data "{\"hf_repo_id\":\"${BAKEOFF_WINNER:-BAAI/bge-small-en-v1.5}\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
url = f"https://run.huggingbay.xyz/v1/bakeoffs/{env('BAKEOFF_ID', 'bo_00000000000000000000000000000000')}/claim"
headers = {'Content-Type': 'application/json'}
payload = {'hf_repo_id': env("BAKEOFF_WINNER", "BAAI/bge-small-en-v1.5")}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/bakeoffs/${env("BAKEOFF_ID", "bo_00000000000000000000000000000000")}/claim`;
const headers = {};
headers["Content-Type"] = "application/json";
const payload = {
  "hf_repo_id": env("BAKEOFF_WINNER", "BAAI/bge-small-en-v1.5")
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/cache" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/cache"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/cache`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/discover" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"query\":\"small English embedding model for semantic search\",\"kind\":\"embedding\",\"limit\":3,\"prefer_warm\":true}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/discover"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'query': 'small English embedding model for semantic search', 'kind': 'embedding', 'limit': 3, 'prefer_warm': True}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/discover`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "query": "small English embedding model for semantic search",
  "kind": "embedding",
  "limit": 3,
  "prefer_warm": true
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/eval" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"task\":\"embedding\",\"models\":[\"sentence-transformers/all-MiniLM-L6-v2\",\"BAAI/bge-small-en-v1.5\"],\"dataset\":[{\"query\":\"receipt verification\",\"positive\":\"verify stored hashes and route evidence\",\"negatives\":[\"today's weather\"]}],\"k\":1,\"prefer_warm\":true}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/eval"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task': 'embedding', 'models': ['sentence-transformers/all-MiniLM-L6-v2', 'BAAI/bge-small-en-v1.5'], 'dataset': [{'query': 'receipt verification', 'positive': 'verify stored hashes and route evidence', 'negatives': ["today's weather"]}], 'k': 1, 'prefer_warm': True}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/eval`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "task": "embedding",
  "models": [
    "sentence-transformers/all-MiniLM-L6-v2",
    "BAAI/bge-small-en-v1.5"
  ],
  "dataset": [
    {
      "query": "receipt verification",
      "positive": "verify stored hashes and route evidence",
      "negatives": [
        "today's weather"
      ]
    }
  ],
  "k": 1,
  "prefer_warm": true
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X DELETE \
  "https://run.huggingbay.xyz/v1/eval/namespaces/${EVALUATION_NAMESPACE:-developers-portal-test}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/eval/namespaces/{env('EVALUATION_NAMESPACE', 'developers-portal-test')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("DELETE", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/eval/namespaces/${env("EVALUATION_NAMESPACE", "developers-portal-test")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "DELETE", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/find_specialist" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"task\":\"Classify short customer messages by sentiment\",\"my_examples\":[{\"text\":\"Great setup\",\"label\":\"positive\"},{\"text\":\"Broken checkout\",\"label\":\"negative\"}],\"kind\":\"classification\",\"n_candidates\":2,\"k\":1}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/find_specialist"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task': 'Classify short customer messages by sentiment', 'my_examples': [{'text': 'Great setup', 'label': 'positive'}, {'text': 'Broken checkout', 'label': 'negative'}], 'kind': 'classification', 'n_candidates': 2, 'k': 1}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/find_specialist`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "task": "Classify short customer messages by sentiment",
  "my_examples": [
    {
      "text": "Great setup",
      "label": "positive"
    },
    {
      "text": "Broken checkout",
      "label": "negative"
    }
  ],
  "kind": "classification",
  "n_candidates": 2,
  "k": 1
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/models" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/models"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/models`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/request_specialist" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"task\":\"English semantic search over support articles\",\"kind\":\"embedding\",\"n_candidates\":3}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/request_specialist"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task': 'English semantic search over support articles', 'kind': 'embedding', 'n_candidates': 3}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/request_specialist`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "task": "English semantic search over support articles",
  "kind": "embedding",
  "n_candidates": 3
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/route" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"kind\":\"embedding\",\"input\":\"A short document for semantic search\",\"serve\":false,\"prefer_warm\":true}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/route"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'kind': 'embedding', 'input': 'A short document for semantic search', 'serve': False, 'prefer_warm': True}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/route`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "kind": "embedding",
  "input": "A short document for semantic search",
  "serve": false,
  "prefer_warm": true
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/solve" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"task_description\":\"Classify customer feedback by sentiment\",\"input\":\"The checkout was fast and helpful.\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/solve"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task_description': 'Classify customer feedback by sentiment', 'input': 'The checkout was fast and helpful.'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/solve`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "task_description": "Classify customer feedback by sentiment",
  "input": "The checkout was fast and helpful."
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/speed-test" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/speed-test"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("POST", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/speed-test`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "POST", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/task/approval" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_TEST_MANAGEMENT_KEY:?set BAY_RUN_TEST_MANAGEMENT_KEY}" \
  --data "{\"quote_id\":\"${QUOTE_ID:-quote_developers_portal_test}\",\"hard_max_price_usd\":0.01,\"idempotency_key\":\"developers-portal-approval-test-v1\",\"expires_in_seconds\":300}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_TEST_MANAGEMENT_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/approval"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'quote_id': env("QUOTE_ID", "quote_developers_portal_test"), 'hard_max_price_usd': 0.01, 'idempotency_key': 'developers-portal-approval-test-v1', 'expires_in_seconds': 300}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/approval`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_TEST_MANAGEMENT_KEY}`;
const payload = {
  "quote_id": env("QUOTE_ID", "quote_developers_portal_test"),
  "hard_max_price_usd": 0.01,
  "idempotency_key": "developers-portal-approval-test-v1",
  "expires_in_seconds": 300
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/task/feedback" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"execution_id\":\"${EXECUTION_ID:-exec_developers_portal_test}\",\"outcome\":\"accepted\",\"rating\":5,\"reason_code\":\"developer_portal_example\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/feedback"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'execution_id': env("EXECUTION_ID", "exec_developers_portal_test"), 'outcome': 'accepted', 'rating': 5, 'reason_code': 'developer_portal_example'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/feedback`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "execution_id": env("EXECUTION_ID", "exec_developers_portal_test"),
  "outcome": "accepted",
  "rating": 5,
  "reason_code": "developer_portal_example"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/task/policy?environment=dev" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/policy?environment=dev"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/policy?environment=dev`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X PUT \
  "https://run.huggingbay.xyz/v1/task/policy" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_TEST_MANAGEMENT_KEY:?set BAY_RUN_TEST_MANAGEMENT_KEY}" \
  --data "{\"environment\":\"dev\",\"per_call_max_usd\":0.01,\"daily_limit_usd\":1,\"active\":true}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_TEST_MANAGEMENT_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/policy"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'environment': 'dev', 'per_call_max_usd': 0.01, 'daily_limit_usd': 1, 'active': True}
response = requests.request("PUT", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/policy`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_TEST_MANAGEMENT_KEY}`;
const payload = {
  "environment": "dev",
  "per_call_max_usd": 0.01,
  "daily_limit_usd": 1,
  "active": true
};
const response = await fetch(url, { method: "PUT", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/task/profiles/${PROFILE_ID:-profile_developers_portal_test}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/profiles/{env('PROFILE_ID', 'profile_developers_portal_test')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/profiles/${env("PROFILE_ID", "profile_developers_portal_test")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X DELETE \
  "https://run.huggingbay.xyz/v1/task/profiles/${PROFILE_ID:-profile_developers_portal_test}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/profiles/{env('PROFILE_ID', 'profile_developers_portal_test')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("DELETE", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/profiles/${env("PROFILE_ID", "profile_developers_portal_test")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "DELETE", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/task/quote" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"task\":{\"task\":\"Classify short support messages by workflow\",\"kind\":\"classification\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"text\":{\"type\":\"string\"}},\"required\":[\"text\"]},\"output_schema\":{\"type\":\"object\",\"properties\":{\"label\":{\"type\":\"string\"}},\"required\":[\"label\"]},\"examples\":[{\"text\":\"Cannot sign in\",\"label\":\"access_issue\"},{\"text\":\"Refund the invoice\",\"label\":\"billing_issue\"},{\"text\":\"Shipment is late\",\"label\":\"delivery_issue\"}],\"constraints\":{\"minimum_quality\":0.5,\"max_latency_ms\":20000,\"max_price_usd\":0.01},\"data_policy\":{\"retention\":\"none\",\"external_apis_allowed\":false,\"use_for_training\":false},\"environment\":\"development\"},\"quote_ttl_seconds\":900,\"idempotency_key\":\"${BAY_RUN_QUOTE_IDEMPOTENCY_KEY:-developers-portal-quote-v1}\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/quote"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task': {'task': 'Classify short support messages by workflow', 'kind': 'classification', 'input_schema': {'type': 'object', 'properties': {'text': {'type': 'string'}}, 'required': ['text']}, 'output_schema': {'type': 'object', 'properties': {'label': {'type': 'string'}}, 'required': ['label']}, 'examples': [{'text': 'Cannot sign in', 'label': 'access_issue'}, {'text': 'Refund the invoice', 'label': 'billing_issue'}, {'text': 'Shipment is late', 'label': 'delivery_issue'}], 'constraints': {'minimum_quality': 0.5, 'max_latency_ms': 20000, 'max_price_usd': 0.01}, 'data_policy': {'retention': 'none', 'external_apis_allowed': False, 'use_for_training': False}, 'environment': 'development'}, 'quote_ttl_seconds': 900, 'idempotency_key': env("BAY_RUN_QUOTE_IDEMPOTENCY_KEY", "developers-portal-quote-v1")}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/quote`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "task": {
    "task": "Classify short support messages by workflow",
    "kind": "classification",
    "input_schema": {
      "type": "object",
      "properties": {
        "text": {
          "type": "string"
        }
      },
      "required": [
        "text"
      ]
    },
    "output_schema": {
      "type": "object",
      "properties": {
        "label": {
          "type": "string"
        }
      },
      "required": [
        "label"
      ]
    },
    "examples": [
      {
        "text": "Cannot sign in",
        "label": "access_issue"
      },
      {
        "text": "Refund the invoice",
        "label": "billing_issue"
      },
      {
        "text": "Shipment is late",
        "label": "delivery_issue"
      }
    ],
    "constraints": {
      "minimum_quality": 0.5,
      "max_latency_ms": 20000,
      "max_price_usd": 0.01
    },
    "data_policy": {
      "retention": "none",
      "external_apis_allowed": false,
      "use_for_training": false
    },
    "environment": "development"
  },
  "quote_ttl_seconds": 900,
  "idempotency_key": env("BAY_RUN_QUOTE_IDEMPOTENCY_KEY", "developers-portal-quote-v1")
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/task/run" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"task\":{\"task\":\"Classify short support messages by workflow\",\"kind\":\"classification\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"text\":{\"type\":\"string\"}},\"required\":[\"text\"]},\"output_schema\":{\"type\":\"object\",\"properties\":{\"label\":{\"type\":\"string\"}},\"required\":[\"label\"]},\"examples\":[{\"text\":\"Cannot sign in\",\"label\":\"access_issue\"},{\"text\":\"Refund the invoice\",\"label\":\"billing_issue\"},{\"text\":\"Shipment is late\",\"label\":\"delivery_issue\"}],\"constraints\":{\"minimum_quality\":0.5,\"max_latency_ms\":20000,\"max_price_usd\":0.01},\"data_policy\":{\"retention\":\"none\",\"external_apis_allowed\":false,\"use_for_training\":false},\"environment\":\"development\"},\"input\":{\"text\":\"The checkout keeps rejecting my card.\"},\"max_price_usd\":0.01,\"idempotency_key\":\"${BAY_RUN_EXECUTION_IDEMPOTENCY_KEY:-developers-portal-run-v1}\",\"payment_mode\":\"demo\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/run"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task': {'task': 'Classify short support messages by workflow', 'kind': 'classification', 'input_schema': {'type': 'object', 'properties': {'text': {'type': 'string'}}, 'required': ['text']}, 'output_schema': {'type': 'object', 'properties': {'label': {'type': 'string'}}, 'required': ['label']}, 'examples': [{'text': 'Cannot sign in', 'label': 'access_issue'}, {'text': 'Refund the invoice', 'label': 'billing_issue'}, {'text': 'Shipment is late', 'label': 'delivery_issue'}], 'constraints': {'minimum_quality': 0.5, 'max_latency_ms': 20000, 'max_price_usd': 0.01}, 'data_policy': {'retention': 'none', 'external_apis_allowed': False, 'use_for_training': False}, 'environment': 'development'}, 'input': {'text': 'The checkout keeps rejecting my card.'}, 'max_price_usd': 0.01, 'idempotency_key': env("BAY_RUN_EXECUTION_IDEMPOTENCY_KEY", "developers-portal-run-v1"), 'payment_mode': 'demo'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/run`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "task": {
    "task": "Classify short support messages by workflow",
    "kind": "classification",
    "input_schema": {
      "type": "object",
      "properties": {
        "text": {
          "type": "string"
        }
      },
      "required": [
        "text"
      ]
    },
    "output_schema": {
      "type": "object",
      "properties": {
        "label": {
          "type": "string"
        }
      },
      "required": [
        "label"
      ]
    },
    "examples": [
      {
        "text": "Cannot sign in",
        "label": "access_issue"
      },
      {
        "text": "Refund the invoice",
        "label": "billing_issue"
      },
      {
        "text": "Shipment is late",
        "label": "delivery_issue"
      }
    ],
    "constraints": {
      "minimum_quality": 0.5,
      "max_latency_ms": 20000,
      "max_price_usd": 0.01
    },
    "data_policy": {
      "retention": "none",
      "external_apis_allowed": false,
      "use_for_training": false
    },
    "environment": "development"
  },
  "input": {
    "text": "The checkout keeps rejecting my card."
  },
  "max_price_usd": 0.01,
  "idempotency_key": env("BAY_RUN_EXECUTION_IDEMPOTENCY_KEY", "developers-portal-run-v1"),
  "payment_mode": "demo"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/task/verify" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"execution_id\":\"${EXECUTION_ID:-exec_developers_portal_test}\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/task/verify"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'execution_id': env("EXECUTION_ID", "exec_developers_portal_test")}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/task/verify`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "execution_id": env("EXECUTION_ID", "exec_developers_portal_test")
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/job-callbacks" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/job-callbacks"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/job-callbacks`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/job-callbacks" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"url\":\"https://example.com/bay-run-developers-portal-test\",\"secret\":\"developers-portal-test-secret-0001\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/job-callbacks"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'url': 'https://example.com/bay-run-developers-portal-test', 'secret': 'developers-portal-test-secret-0001'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/job-callbacks`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "url": "https://example.com/bay-run-developers-portal-test",
  "secret": "developers-portal-test-secret-0001"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/job-callbacks/${CALLBACK_ID:-00000000-0000-4000-8000-000000000000}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/job-callbacks/{env('CALLBACK_ID', '00000000-0000-4000-8000-000000000000')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/job-callbacks/${env("CALLBACK_ID", "00000000-0000-4000-8000-000000000000")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X DELETE \
  "https://run.huggingbay.xyz/v1/job-callbacks/${CALLBACK_ID:-00000000-0000-4000-8000-000000000000}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/job-callbacks/{env('CALLBACK_ID', '00000000-0000-4000-8000-000000000000')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("DELETE", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/job-callbacks/${env("CALLBACK_ID", "00000000-0000-4000-8000-000000000000")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "DELETE", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/jobs" \
  -H 'Idempotency-Key: developers-portal-job-v1' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"items\":[{\"id\":\"calculate-1\",\"operation\":\"calculate\",\"arguments\":{\"expression\":\"6 * 7\"}}]}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs"
headers = {'Idempotency-Key': 'developers-portal-job-v1', 'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'items': [{'id': 'calculate-1', 'operation': 'calculate', 'arguments': {'expression': '6 * 7'}}]}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs`;
const headers = {};
headers["Idempotency-Key"] = "developers-portal-job-v1";
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "items": [
    {
      "id": "calculate-1",
      "operation": "calculate",
      "arguments": {
        "expression": "6 * 7"
      }
    }
  ]
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/jobs/${JOB_ID:-00000000-0000-4000-8000-000000000000}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs/{env('JOB_ID', '00000000-0000-4000-8000-000000000000')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs/${env("JOB_ID", "00000000-0000-4000-8000-000000000000")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/jobs/${JOB_ID:-00000000-0000-4000-8000-000000000000}/callback" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs/{env('JOB_ID', '00000000-0000-4000-8000-000000000000')}/callback"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs/${env("JOB_ID", "00000000-0000-4000-8000-000000000000")}/callback`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/jobs/${JOB_ID:-00000000-0000-4000-8000-000000000000}/callback/abandon" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs/{env('JOB_ID', '00000000-0000-4000-8000-000000000000')}/callback/abandon"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("POST", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs/${env("JOB_ID", "00000000-0000-4000-8000-000000000000")}/callback/abandon`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "POST", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/jobs/${JOB_ID:-00000000-0000-4000-8000-000000000000}/callback/retry" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs/{env('JOB_ID', '00000000-0000-4000-8000-000000000000')}/callback/retry"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("POST", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs/${env("JOB_ID", "00000000-0000-4000-8000-000000000000")}/callback/retry`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "POST", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/jobs/${JOB_ID:-00000000-0000-4000-8000-000000000000}/cancel" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs/{env('JOB_ID', '00000000-0000-4000-8000-000000000000')}/cancel"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("POST", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs/${env("JOB_ID", "00000000-0000-4000-8000-000000000000")}/cancel`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "POST", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/jobs/${JOB_ID:-00000000-0000-4000-8000-000000000000}/result" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/jobs/{env('JOB_ID', '00000000-0000-4000-8000-000000000000')}/result"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/jobs/${env("JOB_ID", "00000000-0000-4000-8000-000000000000")}/result`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/feature-requests" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"title\":\"Stable SDK response examples\",\"description\":\"Publish bounded response examples for developer contract tests.\",\"category\":\"api\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/feature-requests"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'title': 'Stable SDK response examples', 'description': 'Publish bounded response examples for developer contract tests.', 'category': 'api'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/feature-requests`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "title": "Stable SDK response examples",
  "description": "Publish bounded response examples for developer contract tests.",
  "category": "api"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/mirror-requests" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"artifact_id\":\"developers-portal-smoke-artifact\",\"use_case\":\"Documentation request-shape verification\",\"target_tool\":\"developer-portal\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/mirror-requests"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'artifact_id': 'developers-portal-smoke-artifact', 'use_case': 'Documentation request-shape verification', 'target_tool': 'developer-portal'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/mirror-requests`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "artifact_id": "developers-portal-smoke-artifact",
  "use_case": "Documentation request-shape verification",
  "target_tool": "developer-portal"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/open-source-radar?limit=5" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/open-source-radar?limit=5"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/open-source-radar?limit=5`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/request-status?limit=10" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/request-status?limit=10"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/request-status?limit=10`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/request-status/${REQUEST_ID:-brr_0000000000000000}" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/request-status/{env('REQUEST_ID', 'brr_0000000000000000')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/request-status/${env("REQUEST_ID", "brr_0000000000000000")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/source-requests" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"source\":\"huggingface\",\"repo\":\"BAAI/bge-small-en-v1.5\",\"repo_type\":\"model\",\"use_case\":\"Developer portal example\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/source-requests"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'source': 'huggingface', 'repo': 'BAAI/bge-small-en-v1.5', 'repo_type': 'model', 'use_case': 'Developer portal example'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/source-requests`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "source": "huggingface",
  "repo": "BAAI/bge-small-en-v1.5",
  "repo_type": "model",
  "use_case": "Developer portal example"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/developer/credentials?limit=10" \
  -H "Authorization: Bearer ${BAY_RUN_OAUTH_TOKEN:?set BAY_RUN_OAUTH_TOKEN}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OAUTH_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/developer/credentials?limit=10"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/developer/credentials?limit=10`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OAUTH_TOKEN}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/developer/credentials" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_OAUTH_TOKEN:?set BAY_RUN_OAUTH_TOKEN}" \
  --data "{\"name\":\"developers-portal-live-smoke\",\"scopes\":[\"models:read\"]}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OAUTH_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/developer/credentials"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'name': 'developers-portal-live-smoke', 'scopes': ['models:read']}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/developer/credentials`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OAUTH_TOKEN}`;
const payload = {
  "name": "developers-portal-live-smoke",
  "scopes": [
    "models:read"
  ]
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X DELETE \
  "https://run.huggingbay.xyz/v1/developer/credentials/${CREDENTIAL_ID:-brc_00000000000000000000000000000000}" \
  -H "Authorization: Bearer ${BAY_RUN_OAUTH_TOKEN:?set BAY_RUN_OAUTH_TOKEN}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OAUTH_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/developer/credentials/{env('CREDENTIAL_ID', 'brc_00000000000000000000000000000000')}"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("DELETE", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/developer/credentials/${env("CREDENTIAL_ID", "brc_00000000000000000000000000000000")}`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OAUTH_TOKEN}`;
const response = await fetch(url, { method: "DELETE", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/developer/credentials/${CREDENTIAL_ID:-brc_00000000000000000000000000000000}/receipts?limit=10" \
  -H "Authorization: Bearer ${BAY_RUN_OAUTH_TOKEN:?set BAY_RUN_OAUTH_TOKEN}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OAUTH_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/developer/credentials/{env('CREDENTIAL_ID', 'brc_00000000000000000000000000000000')}/receipts?limit=10"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/developer/credentials/${env("CREDENTIAL_ID", "brc_00000000000000000000000000000000")}/receipts?limit=10`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OAUTH_TOKEN}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/developer/credentials/${CREDENTIAL_ID:-brc_00000000000000000000000000000000}/rotate" \
  -H "Authorization: Bearer ${BAY_RUN_OAUTH_TOKEN:?set BAY_RUN_OAUTH_TOKEN}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OAUTH_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/developer/credentials/{env('CREDENTIAL_ID', 'brc_00000000000000000000000000000000')}/rotate"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("POST", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/developer/credentials/${env("CREDENTIAL_ID", "brc_00000000000000000000000000000000")}/rotate`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OAUTH_TOKEN}`;
const response = await fetch(url, { method: "POST", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/memory?namespace=developers-portal-test&limit=10" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory?namespace=developers-portal-test&limit=10"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory?namespace=developers-portal-test&limit=10`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/memory" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"namespace\":\"developers-portal-test\",\"key\":\"last_example\",\"value\":{\"route\":\"developers\"},\"ttl\":300}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'namespace': 'developers-portal-test', 'key': 'last_example', 'value': {'route': 'developers'}, 'ttl': 300}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "namespace": "developers-portal-test",
  "key": "last_example",
  "value": {
    "route": "developers"
  },
  "ttl": 300
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X PATCH \
  "https://run.huggingbay.xyz/v1/memory" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"namespace\":\"developers-portal-test\",\"key\":\"last_example\",\"ttl\":600}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'namespace': 'developers-portal-test', 'key': 'last_example', 'ttl': 600}
response = requests.request("PATCH", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "namespace": "developers-portal-test",
  "key": "last_example",
  "ttl": 600
};
const response = await fetch(url, { method: "PATCH", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X DELETE \
  "https://run.huggingbay.xyz/v1/memory?namespace=developers-portal-test&key=last_example" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory?namespace=developers-portal-test&key=last_example"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("DELETE", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory?namespace=developers-portal-test&key=last_example`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "DELETE", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/memory/context" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"namespace\":\"developers-portal-test\",\"updates\":{\"last_example\":{\"route\":\"developers\"}},\"ttl\":300}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory/context"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'namespace': 'developers-portal-test', 'updates': {'last_example': {'route': 'developers'}}, 'ttl': 300}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory/context`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "namespace": "developers-portal-test",
  "updates": {
    "last_example": {
      "route": "developers"
    }
  },
  "ttl": 300
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/memory/context-pack?namespace=developers-portal-test&limit=10" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory/context-pack?namespace=developers-portal-test&limit=10"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory/context-pack?namespace=developers-portal-test&limit=10`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/memory/context-pack" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"pack\":{\"schema\":\"bay-run.memory-context-pack.v1\",\"version\":1,\"items\":[]},\"namespace\":\"developers-portal-test\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory/context-pack"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'pack': {'schema': 'bay-run.memory-context-pack.v1', 'version': 1, 'items': []}, 'namespace': 'developers-portal-test'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory/context-pack`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "pack": {
    "schema": "bay-run.memory-context-pack.v1",
    "version": 1,
    "items": []
  },
  "namespace": "developers-portal-test"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/memory/export?namespace=developers-portal-test&limit=10" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory/export?namespace=developers-portal-test&limit=10"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory/export?namespace=developers-portal-test&limit=10`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X PATCH \
  "https://run.huggingbay.xyz/v1/memory/importance" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"namespace\":\"developers-portal-test\",\"key\":\"last_example\",\"importance\":80}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory/importance"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'namespace': 'developers-portal-test', 'key': 'last_example', 'importance': 80}
response = requests.request("PATCH", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory/importance`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "namespace": "developers-portal-test",
  "key": "last_example",
  "importance": 80
};
const response = await fetch(url, { method: "PATCH", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/memory/search" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"query\":\"developer route\",\"namespace\":\"developers-portal-test\",\"limit\":10,\"semantic\":false}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/memory/search"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'query': 'developer route', 'namespace': 'developers-portal-test', 'limit': 10, 'semantic': False}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/memory/search`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "query": "developer route",
  "namespace": "developers-portal-test",
  "limit": 10,
  "semantic": false
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/billing?limit=5" \
  -H "Authorization: Bearer ${BAY_RUN_OPERATOR_TOKEN:?set BAY_RUN_OPERATOR_TOKEN}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OPERATOR_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/billing?limit=5"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/billing?limit=5`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OPERATOR_TOKEN}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/billing/balance" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/billing/balance"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/billing/balance`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/billing/stripe/checkout-session" \
  -H 'Idempotency-Key: developers-portal-payment-test-v1' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_TEST_MANAGEMENT_KEY:?set BAY_RUN_TEST_MANAGEMENT_KEY}" \
  --data "{\"pack_code\":\"starter_1000\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_TEST_MANAGEMENT_KEY"]
url = f"https://run.huggingbay.xyz/v1/billing/stripe/checkout-session"
headers = {'Idempotency-Key': 'developers-portal-payment-test-v1', 'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'pack_code': 'starter_1000'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/billing/stripe/checkout-session`;
const headers = {};
headers["Idempotency-Key"] = "developers-portal-payment-test-v1";
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_TEST_MANAGEMENT_KEY}`;
const payload = {
  "pack_code": "starter_1000"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/billing/usage?limit=10&format=json" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/billing/usage?limit=10&format=json"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/billing/usage?limit=10&format=json`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/credits/chat/completions" \
  -H 'Idempotency-Key: developers-portal-payment-test-v1' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_TEST_SPEND_KEY:?set BAY_RUN_TEST_SPEND_KEY}" \
  --data "{\"model\":\"Qwen/Qwen3-4B\",\"messages\":[{\"role\":\"user\",\"content\":\"Say test mode in two words.\"}],\"max_tokens\":8}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_TEST_SPEND_KEY"]
url = f"https://run.huggingbay.xyz/v1/credits/chat/completions"
headers = {'Idempotency-Key': 'developers-portal-payment-test-v1', 'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'model': 'Qwen/Qwen3-4B', 'messages': [{'role': 'user', 'content': 'Say test mode in two words.'}], 'max_tokens': 8}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/credits/chat/completions`;
const headers = {};
headers["Idempotency-Key"] = "developers-portal-payment-test-v1";
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_TEST_SPEND_KEY}`;
const payload = {
  "model": "Qwen/Qwen3-4B",
  "messages": [
    {
      "role": "user",
      "content": "Say test mode in two words."
    }
  ],
  "max_tokens": 8
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/credits/tasks/run" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_TEST_SPEND_KEY:?set BAY_RUN_TEST_SPEND_KEY}" \
  --data "{\"task\":{\"task\":\"Classify short support messages by workflow\",\"kind\":\"classification\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"text\":{\"type\":\"string\"}},\"required\":[\"text\"]},\"output_schema\":{\"type\":\"object\",\"properties\":{\"label\":{\"type\":\"string\"}},\"required\":[\"label\"]},\"examples\":[{\"text\":\"Cannot sign in\",\"label\":\"access_issue\"},{\"text\":\"Refund the invoice\",\"label\":\"billing_issue\"},{\"text\":\"Shipment is late\",\"label\":\"delivery_issue\"}],\"constraints\":{\"minimum_quality\":0.5,\"max_latency_ms\":20000,\"max_price_usd\":0.01},\"data_policy\":{\"retention\":\"none\",\"external_apis_allowed\":false,\"use_for_training\":false},\"environment\":\"development\"},\"input\":{\"text\":\"The checkout keeps rejecting my card.\"},\"max_price_usd\":0.01,\"idempotency_key\":\"developers-portal-stripe-test-v1\",\"payment_mode\":\"stripe_credits\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_TEST_SPEND_KEY"]
url = f"https://run.huggingbay.xyz/v1/credits/tasks/run"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'task': {'task': 'Classify short support messages by workflow', 'kind': 'classification', 'input_schema': {'type': 'object', 'properties': {'text': {'type': 'string'}}, 'required': ['text']}, 'output_schema': {'type': 'object', 'properties': {'label': {'type': 'string'}}, 'required': ['label']}, 'examples': [{'text': 'Cannot sign in', 'label': 'access_issue'}, {'text': 'Refund the invoice', 'label': 'billing_issue'}, {'text': 'Shipment is late', 'label': 'delivery_issue'}], 'constraints': {'minimum_quality': 0.5, 'max_latency_ms': 20000, 'max_price_usd': 0.01}, 'data_policy': {'retention': 'none', 'external_apis_allowed': False, 'use_for_training': False}, 'environment': 'development'}, 'input': {'text': 'The checkout keeps rejecting my card.'}, 'max_price_usd': 0.01, 'idempotency_key': 'developers-portal-stripe-test-v1', 'payment_mode': 'stripe_credits'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/credits/tasks/run`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_TEST_SPEND_KEY}`;
const payload = {
  "task": {
    "task": "Classify short support messages by workflow",
    "kind": "classification",
    "input_schema": {
      "type": "object",
      "properties": {
        "text": {
          "type": "string"
        }
      },
      "required": [
        "text"
      ]
    },
    "output_schema": {
      "type": "object",
      "properties": {
        "label": {
          "type": "string"
        }
      },
      "required": [
        "label"
      ]
    },
    "examples": [
      {
        "text": "Cannot sign in",
        "label": "access_issue"
      },
      {
        "text": "Refund the invoice",
        "label": "billing_issue"
      },
      {
        "text": "Shipment is late",
        "label": "delivery_issue"
      }
    ],
    "constraints": {
      "minimum_quality": 0.5,
      "max_latency_ms": 20000,
      "max_price_usd": 0.01
    },
    "data_policy": {
      "retention": "none",
      "external_apis_allowed": false,
      "use_for_training": false
    },
    "environment": "development"
  },
  "input": {
    "text": "The checkout keeps rejecting my card."
  },
  "max_price_usd": 0.01,
  "idempotency_key": "developers-portal-stripe-test-v1",
  "payment_mode": "stripe_credits"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/demand?limit=5" \
  -H "Authorization: Bearer ${BAY_RUN_OPERATOR_TOKEN:?set BAY_RUN_OPERATOR_TOKEN}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_OPERATOR_TOKEN"]
url = f"https://run.huggingbay.xyz/v1/demand?limit=5"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/demand?limit=5`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_OPERATOR_TOKEN}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X GET \
  "https://run.huggingbay.xyz/v1/usage" \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/usage"
headers = {}
headers["Authorization"] = f"Bearer {token}"
response = requests.request("GET", url, headers=headers, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/usage`;
const headers = {};
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const response = await fetch(url, { method: "GET", headers });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/calculate" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"expression\":\"6 * 7\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/calculate"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'expression': '6 * 7'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/calculate`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "expression": "6 * 7"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/provenance/verify" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"receipt\":{}}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/provenance/verify"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'receipt': {}}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/provenance/verify`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "receipt": {}
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/resolve_link" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"url\":\"https://run.huggingbay.xyz/status.json\"}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/resolve_link"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'url': 'https://run.huggingbay.xyz/status.json'}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/resolve_link`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "url": "https://run.huggingbay.xyz/status.json"
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

curl --fail-with-body --silent --show-error -X POST \
  "https://run.huggingbay.xyz/v1/validate_json" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer ${BAY_RUN_DEVELOPER_KEY:?set BAY_RUN_DEVELOPER_KEY}" \
  --data "{\"data\":{\"answer\":42},\"schema\":{\"type\":\"object\",\"properties\":{\"answer\":{\"type\":\"integer\"}},\"required\":[\"answer\"]}}"

import os
import requests

env = lambda name, fallback: os.environ.get(name, fallback)
token = os.environ["BAY_RUN_DEVELOPER_KEY"]
url = f"https://run.huggingbay.xyz/v1/validate_json"
headers = {'Content-Type': 'application/json'}
headers["Authorization"] = f"Bearer {token}"
payload = {'data': {'answer': 42}, 'schema': {'type': 'object', 'properties': {'answer': {'type': 'integer'}}, 'required': ['answer']}}
response = requests.request("POST", url, headers=headers, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

const env = (name, fallback) => process.env[name] || fallback;
const url = `https://run.huggingbay.xyz/v1/validate_json`;
const headers = {};
headers["Content-Type"] = "application/json";
headers["Authorization"] = `Bearer ${process.env.BAY_RUN_DEVELOPER_KEY}`;
const payload = {
  "data": {
    "answer": 42
  },
  "schema": {
    "type": "object",
    "properties": {
      "answer": {
        "type": "integer"
      }
    },
    "required": [
      "answer"
    ]
  }
};
const response = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());