Albus for coding agents

import os

from albus_sdk import Albus

albus = Albus(api_key=os.environ["ALBUS_API_KEY"])

import { Albus } from "@albus-ts/sdk";

const albus = new Albus({
  security: { apiKey: process.env.ALBUS_API_KEY ?? "" },
});

response = albus.sessions.run_session(
    id="support-1234",
    invocation_key="support-1234-triage-1",
    user_prompt="Customer says login fails after the password reset. Triage it.",
    agent_name="support-triage",
    agent={
        "model": {"name": "gemini-3.6-flash"},
        "system_prompt": "You triage support tickets. Be terse.",
        "tools": {"web_search": {}, "terminal": {}},
    },
    wait_timeout_seconds=300,
)
print(response.result.session.state)          # DONE
print(response.result.message.content)        # the reply to this prompt

const response = await albus.sessions.runSession({
  id: "support-1234",
  invocationKey: "support-1234-triage-1",
  waitTimeoutSeconds: 300,
  body: {
    userPrompt: "Customer says login fails after the password reset. Triage it.",
    agentName: "support-triage",
    agent: {
      model: { name: "gemini-3.6-flash" },
      systemPrompt: "You triage support tickets. Be terse.",
      tools: { webSearch: {}, terminal: {} },
    },
  },
});
console.log(response.result.session.state);   // DONE
console.log(response.result.message?.content);

from albus_sdk import errors

for _ in range(3):
    try:
        response = albus.sessions.run_session(
            id="support-1234",
            invocation_key="support-1234-triage-1",
            user_prompt="Triage this ticket.",
            agent_name="support-triage",
            agent={"model": {"name": "gemini-3.6-flash"}},
            wait_timeout_seconds=120,
        )
        print(response.result.message.content)
        break
    except errors.ErrTimeout:
        continue                       # 504: still running, same key re-attaches
else:
    print("still running; poll GET /sessions/support-1234")

import { ErrTimeout } from "@albus-ts/sdk/models/errors";

for (let attempt = 0; attempt < 3; attempt++) {
  try {
    const response = await albus.sessions.runSession({
      id: "support-1234",
      invocationKey: "support-1234-triage-1",
      waitTimeoutSeconds: 120,
      body: {
        userPrompt: "Triage this ticket.",
        agentName: "support-triage",
        agent: { model: { name: "gemini-3.6-flash" } },
      },
    });
    console.log(response.result.message?.content);
    break;
  } catch (error) {
    if (!(error instanceof ErrTimeout)) throw error; // 504: same key re-attaches
  }
}

page = albus.sessions.get_session(id="support-1234", limit=100)
print(page.session.state, page.session.invocation_count, page.session.agent_revision)
for message in page.messages:
    print(message.role, message.content)
while len(page.messages) == 100:
    page = albus.sessions.get_session(
        id="support-1234", after=str(page.messages[-1].cursor), limit=100
    )
    for message in page.messages:
        print(message.role, message.content)

let page = await albus.sessions.getSession({ id: "support-1234", limit: 100 });
console.log(page.session.state, page.session.invocationCount, page.session.agentRevision);
for (const message of page.messages) console.log(message.role, message.content);
while (page.messages.length === 100) {
  page = await albus.sessions.getSession({
    id: "support-1234",
    after: String(page.messages.at(-1)!.cursor),
    limit: 100,
  });
  for (const message of page.messages) console.log(message.role, message.content);
}

page = albus.sessions.list_sessions(agent_name="support-triage", status="FAILED")
for session in page.sessions:
    print(session.id, session.state, session.updated_at)

const page = await albus.sessions.listSessions({
  agentName: "support-triage",
  status: "FAILED",
});
for (const session of page.sessions) console.log(session.id, session.state, session.updatedAt);

albus.sessions.cancel_session(id="support-1234")

await albus.sessions.cancelSession({ id: "support-1234" });

failed = albus.traces.list_traces(agent_name="support-triage", status="FAILED", limit=10)
for summary in failed.traces:
    print(summary.invocation_key, summary.session_id, summary.started_at)

trace = albus.traces.get_trace(invocation_key="support-1234-triage-1").result
print(trace.status, trace.failure)
for span in trace.spans:
    print(span.id, span.type, span.name or "", span.status)
    if span.type == "tool_call":
        print("  in:", span.input)
        print("  out:", span.output)

const failed = await albus.traces.listTraces({
  agentName: "support-triage",
  status: "FAILED",
  limit: 10,
});
for (const summary of failed.traces) {
  console.log(summary.invocationKey, summary.sessionId, summary.startedAt);
}

const { result: trace } = await albus.traces.getTrace({
  invocationKey: "support-1234-triage-1",
});
console.log(trace.status, trace.failure);
for (const span of trace.spans) {
  console.log(span.id, span.type, span.name ?? "", span.status);
}

page = albus.sessions.get_session_audit(id="support-1234", limit=100)
for event in page.events:
    if event.type == "tool_call":
        print(event.event_time, event.agent_revision, event.payload)

const page = await albus.sessions.getSessionAudit({ id: "support-1234", limit: 100 });
for (const event of page.events) {
  if (event.type === "tool_call") console.log(event.eventTime, event.agentRevision, event.payload);
}

after = None
while True:
    page = albus.sessions.get_session_audit(id="support-1234", after=after, limit=500)
    for event in page.events:
        print(event.type)
    after = page.next_cursor
    if not after:
        break

let after: string | undefined;
do {
  const page = await albus.sessions.getSessionAudit({ id: "support-1234", after, limit: 500 });
  for (const event of page.events) console.log(event.type);
  after = page.nextCursor;
} while (after);