API reference

Baseline: talk to OpenAI directly. Sends one OpenAI key in Authorization; no condense involvement. Use this as the control variant when comparing against the proxy tab.

bashcopy# single-turn smoke
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}'

pythoncopy# three-turn tool loop; pip-free
import json, os
from urllib.request import Request, urlopen

URL = "https://api.openai.com/v1/chat/completions"
KEY = os.environ["OPENAI_API_KEY"]

TOOLS = [
  {"type":"function","function":{"name":"add","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}}}}},
  {"type":"function","function":{"name":"mul","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}}}}},
  {"type":"function","function":{"name":"final_answer","parameters":{"type":"object","properties":{"text":{"type":"string"}}}}},
]

def tool(name, args):
  if name == "add": return str(args["a"] + args["b"])
  if name == "mul": return str(args["a"] * args["b"])
  return args["text"]

def post(messages):
  body = json.dumps({"model":"gpt-4o-mini","messages":messages,"tools":TOOLS,"tool_choice":"auto"}).encode()
  req = Request(URL, method="POST", data=body, headers={
    "Authorization": f"Bearer {KEY}",
    "Content-Type": "application/json",
  })
  return json.loads(urlopen(req).read())

messages = [{"role":"user","content":"Compute (17 + 25) * 3 using add and mul, then call final_answer."}]
for _ in range(6):
  msg = post(messages)["choices"][0]["message"]
  if not msg.get("tool_calls"): print(msg.get("content") or ""); break
  messages.append(msg)
  for tc in msg["tool_calls"]:
    args = json.loads(tc["function"]["arguments"] or "{}")
    result = tool(tc["function"]["name"], args)
    print(f"{tc['function']['name']}({args}) -> {result}")
    messages.append({"role":"tool","tool_call_id":tc["id"],"content":result})
    if tc["function"]["name"] == "final_answer": raise SystemExit

Same shape as direct, but the URL is condense's /openai/v1/chat/completions, the condense key rides in X-Condense-Auth-Token, and your OpenAI key stays in Authorization. Condense compresses, forwards, streams back the upstream response — your code doesn't change.

bashcopycurl https://api.condense.chat/openai/v1/chat/completions \
  -H "X-Condense-Auth-Token: $CONDENSE_KEY" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}'

pythoncopy# identical to the direct example, only URL + headers change
import json, os
from urllib.request import Request, urlopen

URL = "https://api.condense.chat/openai/v1/chat/completions"
OAI = os.environ["OPENAI_API_KEY"]
CON = os.environ["CONDENSE_KEY"]

TOOLS = [
  {"type":"function","function":{"name":"add","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}}}}},
  {"type":"function","function":{"name":"mul","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}}}}},
  {"type":"function","function":{"name":"final_answer","parameters":{"type":"object","properties":{"text":{"type":"string"}}}}},
]

def tool(name, args):
  if name == "add": return str(args["a"] + args["b"])
  if name == "mul": return str(args["a"] * args["b"])
  return args["text"]

def post(messages):
  body = json.dumps({"model":"gpt-4o-mini","messages":messages,"tools":TOOLS,"tool_choice":"auto"}).encode()
  req = Request(URL, method="POST", data=body, headers={
    "X-Condense-Auth-Token": CON,
    "Authorization": f"Bearer {OAI}",
    "Content-Type": "application/json",
  })
  return json.loads(urlopen(req).read())

messages = [{"role":"user","content":"Compute (17 + 25) * 3 using add and mul, then call final_answer."}]
for _ in range(6):
  msg = post(messages)["choices"][0]["message"]
  if not msg.get("tool_calls"): print(msg.get("content") or ""); break
  messages.append(msg)
  for tc in msg["tool_calls"]:
    args = json.loads(tc["function"]["arguments"] or "{}")
    result = tool(tc["function"]["name"], args)
    print(f"{tc['function']['name']}({args}) -> {result}")
    messages.append({"role":"tool","tool_call_id":tc["id"],"content":result})
    if tc["function"]["name"] == "final_answer": raise SystemExit

Two-step: condense rewrites your body and hands it back without calling upstream, then you forward it yourself. Header switch is X-Condense-Function: rewrite. No upstream key needed for the first call. Useful when you want to inspect, log, or batch the compressed payload before spending tokens.

bashcopy# step 1 — get the compressed body
curl https://api.condense.chat/openai/v1/chat/completions \
  -H "X-Condense-Auth-Token: $CONDENSE_KEY" \
  -H "X-Condense-Function: rewrite" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}' \
  > rewritten.json

# step 2 — forward it to OpenAI yourself
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d @rewritten.json

pythoncopy# tool loop where every turn is rewrite-then-forward
import json, os
from urllib.request import Request, urlopen

REWRITE  = "https://api.condense.chat/openai/v1/chat/completions"
UPSTREAM = "https://api.openai.com/v1/chat/completions"
OAI = os.environ["OPENAI_API_KEY"]
CON = os.environ["CONDENSE_KEY"]

TOOLS = [
  {"type":"function","function":{"name":"add","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}}}}},
  {"type":"function","function":{"name":"mul","parameters":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}}}}},
  {"type":"function","function":{"name":"final_answer","parameters":{"type":"object","properties":{"text":{"type":"string"}}}}},
]

def tool(name, args):
  if name == "add": return str(args["a"] + args["b"])
  if name == "mul": return str(args["a"] * args["b"])
  return args["text"]

def turn(messages):
  body = json.dumps({"model":"gpt-4o-mini","messages":messages,"tools":TOOLS,"tool_choice":"auto"}).encode()
  rewritten = urlopen(Request(REWRITE, method="POST", data=body, headers={
    "X-Condense-Auth-Token": CON,
    "X-Condense-Function": "rewrite",
    "Content-Type": "application/json",
  })).read()
  return json.loads(urlopen(Request(UPSTREAM, method="POST", data=rewritten, headers={
    "Authorization": f"Bearer {OAI}",
    "Content-Type": "application/json",
  })).read())

messages = [{"role":"user","content":"Compute (17 + 25) * 3 using add and mul, then call final_answer."}]
for _ in range(6):
  msg = turn(messages)["choices"][0]["message"]
  if not msg.get("tool_calls"): print(msg.get("content") or ""); break
  messages.append(msg)
  for tc in msg["tool_calls"]:
    args = json.loads(tc["function"]["arguments"] or "{}")
    result = tool(tc["function"]["name"], args)
    print(f"{tc['function']['name']}({args}) -> {result}")
    messages.append({"role":"tool","tool_call_id":tc["id"],"content":result})
    if tc["function"]["name"] == "final_answer": raise SystemExit

Baseline: talk to Anthropic directly. The Anthropic dialect puts the upstream key in x-api-key (not Authorization) and requires the anthropic-version header. Tools are typed; the model's tool calls come back as tool_use blocks; tool results go back as tool_result blocks.

bashcopycurl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-haiku-4-5-20251001","max_tokens":256,"messages":[{"role":"user","content":"hi"}]}'

pythoncopyimport json, os
from urllib.request import Request, urlopen

URL = "https://api.anthropic.com/v1/messages"
KEY = os.environ["ANTHROPIC_API_KEY"]

TOOLS = [
  {"name":"add","input_schema":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]}},
  {"name":"mul","input_schema":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]}},
  {"name":"final_answer","input_schema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}},
]

def tool(name, args):
  if name == "add": return str(args["a"] + args["b"])
  if name == "mul": return str(args["a"] * args["b"])
  return args["text"]

def post(messages):
  body = json.dumps({
    "model":"claude-haiku-4-5-20251001","max_tokens":1024,
    "messages":messages,"tools":TOOLS,
  }).encode()
  req = Request(URL, method="POST", data=body, headers={
    "x-api-key": KEY,
    "anthropic-version": "2023-06-01",
    "Content-Type": "application/json",
  })
  return json.loads(urlopen(req).read())

messages = [{"role":"user","content":"Compute (17 + 25) * 3 using add and mul, then call final_answer."}]
for _ in range(6):
  resp = post(messages)
  blocks = resp["content"]
  messages.append({"role":"assistant","content":blocks})
  calls = [b for b in blocks if b["type"] == "tool_use"]
  if not calls:
    print("".join(b.get("text", "") for b in blocks)); break
  results = []
  for b in calls:
    result = tool(b["name"], b["input"])
    print(f"{b['name']}({b['input']}) -> {result}")
    results.append({"type":"tool_result","tool_use_id":b["id"],"content":result})
    if b["name"] == "final_answer": raise SystemExit
  messages.append({"role":"user","content":results})

Anthropic two-step. The compressed body comes back from condense and you forward it to api.anthropic.com yourself. x-api-key and anthropic-version are only needed on the upstream forward; the rewrite step takes the condense key alone.

bashcopy# step 1 — get the compressed body
curl https://api.condense.chat/anthropic/v1/messages \
  -H "X-Condense-Auth-Token: $CONDENSE_KEY" \
  -H "X-Condense-Function: rewrite" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-haiku-4-5-20251001","max_tokens":256,"messages":[{"role":"user","content":"hi"}]}' \
  > rewritten.json

# step 2 — forward it to Anthropic yourself
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d @rewritten.json

pythoncopyimport json, os
from urllib.request import Request, urlopen

REWRITE  = "https://api.condense.chat/anthropic/v1/messages"
UPSTREAM = "https://api.anthropic.com/v1/messages"
ANT = os.environ["ANTHROPIC_API_KEY"]
CON = os.environ["CONDENSE_KEY"]

TOOLS = [
  {"name":"add","input_schema":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]}},
  {"name":"mul","input_schema":{"type":"object","properties":{"a":{"type":"number"},"b":{"type":"number"}},"required":["a","b"]}},
  {"name":"final_answer","input_schema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}},
]

def tool(name, args):
  if name == "add": return str(args["a"] + args["b"])
  if name == "mul": return str(args["a"] * args["b"])
  return args["text"]

def turn(messages):
  body = json.dumps({"model":"claude-haiku-4-5-20251001","max_tokens":1024,"messages":messages,"tools":TOOLS}).encode()
  rewritten = urlopen(Request(REWRITE, method="POST", data=body, headers={
    "X-Condense-Auth-Token": CON,
    "X-Condense-Function": "rewrite",
    "Content-Type": "application/json",
  })).read()
  return json.loads(urlopen(Request(UPSTREAM, method="POST", data=rewritten, headers={
    "x-api-key": ANT,
    "anthropic-version": "2023-06-01",
    "Content-Type": "application/json",
  })).read())

messages = [{"role":"user","content":"Compute (17 + 25) * 3 using add and mul, then call final_answer."}]
for _ in range(6):
  resp = turn(messages); blocks = resp["content"]
  messages.append({"role":"assistant","content":blocks})
  calls = [b for b in blocks if b["type"] == "tool_use"]
  if not calls: print("".join(b.get("text", "") for b in blocks)); break
  results = []
  for b in calls:
    result = tool(b["name"], b["input"])
    print(f"{b['name']}({b['input']}) -> {result}")
    results.append({"type":"tool_result","tool_use_id":b["id"],"content":result})
    if b["name"] == "final_answer": raise SystemExit
  messages.append({"role":"user","content":results})

claude-agent-sdk-python is the official Anthropic SDK for spawning long-running tool-using agents. It shells out to claude under the hood, so all you need to do is point its ANTHROPIC_BASE_URL at condense's /anthropic prefix and pass your condense key via the SDK's env option. direct and rewrite modes aren't relevant here — the agent loop needs upstream completions.

bashcopy# install once
pip install claude-agent-sdk
npm install -g @anthropic-ai/claude-code  # the SDK shells out to this

pythoncopyimport anyio, os
from claude_agent_sdk import query, ClaudeAgentOptions

opts = ClaudeAgentOptions(env={
  "ANTHROPIC_BASE_URL": "https://api.condense.chat/anthropic",
  "ANTHROPIC_CUSTOM_HEADERS": f"X-Condense-Auth-Token: {os.environ['CONDENSE_KEY']}",
  "ANTHROPIC_API_KEY": os.environ["ANT_API_TOKEN"],
})

async def main():
  async for msg in query(prompt="Compute (17 + 25) * 3 step by step.", options=opts):
    print(msg)

anyio.run(main)

Every tool turn passes through condense, which records the chain and (if a compression strategy is configured) compacts older spans before forwarding upstream. Set per-request tuning headers with ANTHROPIC_CUSTOM_HEADERS if you want to override the engine for one session.