SDK Reference

await exe.registerAgent({  agentId: 'support-bot',  name: 'Customer Support Bot',  type: 'chatbot',  platform: 'openai',  environment: 'production',  ownerEmail: 'support-team@example.com',  allowedDataSources: ['postgres://customers'],  allowedActions: ['search_kb', 'create_ticket'],  requiresHumanApprovalFor: ['issue_refund'],  tags: ['support', 'tier-1'],  metadata: { costCenter: 'CS-101' },});

import { AgentPausedError, PolicyBlockedError } from '@execlave/sdk'; try {  await exe.enforcePolicy({ agentId: 'support-bot', input: userQuestion });  const answer = await llm.call(userQuestion);} catch (err) {  if (err instanceof PolicyBlockedError) {    // err.violations: list of { policyType, policyName, severity, message, enforcementMode }    return 'Your input was blocked by our content policies.';  }  if (err instanceof AgentPausedError) {    return 'Service temporarily unavailable.';  }  throw err;}

const trace = exe.startTrace({ agentId: 'support-bot' });trace  .setInput('How do I reset my password?')  .setOutput('Go to Settings > Security...')  .setModel('gpt-4')  .setTokens(150, 320)  .setCost(0.0045)  .finish(); // Or finish with error:trace.finish('error', 'LLM call timed out');

const tracedAnswer = exe.wrap(  async (question: string) => {    const res = await openai.chat.completions.create({      model: 'gpt-4',      messages: [{ role: 'user', content: question }],    });    return res.choices[0].message.content;  },  { agentId: 'support-bot' }); // Usage — fully traced automaticallyconst answer = await tracedAnswer('How do I upgrade?');

const raw = await webSearch(query);await exe.enforceToolOutput({ agentId: 'bot', toolName: 'web_search', output: raw });// Throws PolicyBlockedError if the result carries denied PII or injection.messages.push({ role: 'tool', content: raw });

const v = await exe.verifyApproval(approvalId, { input, environment: 'production' });if (!v.valid) throw new Error(`approval not usable: ${v.reason}`);

if ((await exe.checkAgentStatus('bot')) === 'paused') return;

if (!(await exe.ping())) console.warn('Execlave unreachable');

await exe.flush();

const usage = await exe.checkUsage();

const cred = await exe.getAgentCredential('bot');

const decision = await exe.authorizeAgentCall({ callerAgentId: 'a', targetAgentId: 'b' });

const agents = await exe.discoverAgents('refunds');

await exe.reportAgentMetadata({ agentId: 'bot', framework: 'langchain' });

const d = exe.toolDescriptor({ server: 'files', tool: 'read', descriptor: schema });

await exe.reportToolBaseline({ agentId: 'bot', tools: [d] });

process.on('SIGTERM', async () => {  await exe.shutdown();  process.exit(0);});

agent = exe.register_agent(    agent_id="support-bot",    name="Customer Support Bot",    type="chatbot",    platform="langchain",    owner_email="support-team@example.com",    allowed_actions=["search_kb", "create_ticket"],    requires_human_approval_for=["issue_refund"],    tags=["support", "production"],)

from execlave import AgentPausedError, PolicyBlockedError try:    exe.enforce_policy(agent_id="support-bot", input=user_question)    response = llm.invoke(user_question)except PolicyBlockedError as e:    # e.violations: list of {policyType, policyName, severity, message, enforcementMode}    return "Your input was blocked by our content policies."except AgentPausedError:    return "Service temporarily unavailable."

@exe.tracedef answer(question: str) -> str:    return llm.invoke(question) # Session + user attribution:@exe.trace(session_id="sess_123", user_id="user_42")def handle(query: str) -> str:    return db.execute(query)

with exe.start_trace(agent_id="support-bot") as trace:    trace.set_input(user_question)    response = llm.invoke(user_question)    trace.set_output(response)    trace.set_model("gpt-4")    trace.set_tokens(input=150, output=320)    trace.set_cost(0.0045)    trace.add_metadata({"intent": "password_reset"})

raw = web_search(query)exe.enforce_tool_output(agent_id="bot", tool_name="web_search", output=raw)# Raises PolicyBlockedError if the result carries denied PII or injection.messages.append({"role": "tool", "content": raw})

v = exe.verify_approval(approval_id, {"input": text, "environment": "production"})if not v["valid"]:    raise RuntimeError(f"approval not usable: {v.get('reason')}")

if exe.check_agent_status("bot") == "paused":    return

if not exe.ping():    logger.warning("Execlave unreachable")

exe.flush()

usage = exe.check_usage()

cred = exe.get_agent_credential("bot")

decision = exe.authorize_agent_call(caller_agent_id="a", target_agent_id="b")

agents = exe.discover_agents("refunds")

exe.report_agent_metadata(agent_id="bot", framework="langchain")

d = exe.tool_descriptor(server="files", tool="read", descriptor=schema)

exe.report_tool_baseline(agent_id="bot", tools=[d])