SDK

npm install @superserve/sdk

import Superserve from "@superserve/sdk"

const client = new Superserve({ apiKey: "your-api-key" })

const result = await client.run("code-reviewer", {
  message: "Review the error handling in src/auth.ts",
})

console.log(result.text)
console.log(result.duration)    // 3800
console.log(result.toolCalls)   // [{ name: "read_file", input: {...}, duration: 120 }]

const result = await client.run("code-reviewer", {
  message: "Now fix the issues you found",
  sessionId: "ses_abc123",
})

const stream = client.stream("code-reviewer", {
  message: "Refactor the database connection pool",
  onText: (text) => process.stdout.write(text),
  onToolStart: (tool) => console.log(`-> ${tool.name}`),
  onToolEnd: (tool) => console.log(`done in ${tool.duration}ms`),
  onFinish: (result) => console.log(`\nDone in ${result.duration}ms`),
})

await stream.result

const stream = client.stream("code-reviewer", {
  message: "Write tests for the auth module",
})

for await (const chunk of stream.textStream) {
  process.stdout.write(chunk)
}

const stream = client.stream("code-reviewer", {
  message: "Analyze this codebase",
})

for await (const event of stream) {
  switch (event.type) {
    case "text":
      process.stdout.write(event.content)
      break
    case "tool-start":
      console.log(`Using tool: ${event.name}`)
      break
    case "tool-end":
      console.log(`Tool finished in ${event.duration}ms`)
      break
    case "run-completed":
      console.log(`Run completed in ${event.duration}ms`)
      break
    case "run-failed":
      console.error(`Run failed: ${event.error}`)
      break
  }
}

const session = await client.createSession("code-reviewer", {
  title: "Auth module review",
  idleTimeout: 3600, // 1 hour, in seconds
})

const r1 = await session.run("What files handle authentication?")
// "Authentication is handled in src/auth.ts and src/middleware/auth.ts..."

const r2 = await session.run("Add rate limiting to the login endpoint")
// Agent remembers context from r1

const r3 = session.stream("Now write tests for the rate limiter")
for await (const chunk of r3.textStream) {
  process.stdout.write(chunk)
}

await session.end()

const stream = session.stream("Refactor the auth module", {
  onText: (text) => process.stdout.write(text),
  onToolStart: (tool) => console.log(`-> ${tool.name}`),
  onToolEnd: (tool) => console.log(`done in ${tool.duration}ms`),
  onFinish: (result) => console.log(`\nDone in ${result.duration}ms`),
  onError: (err) => console.error(err),
})

await stream.result

const agents = await client.agents.list()
const agent = await client.agents.get("code-reviewer")

npm install @superserve/sdk react

import { SuperserveProvider, useAgent } from "@superserve/sdk/react"

function App() {
  return (
    <SuperserveProvider apiKey="your-api-key">
      <Chat />
    </SuperserveProvider>
  )
}

function Chat() {
  const { messages, sendMessage, isStreaming, stop } = useAgent({
    agent: "code-reviewer",
    onFinish: (msg) => console.log("Agent responded:", msg.content),
    onError: (err) => console.error("Error:", err),
  })

  return (
    <div>
      {messages.map((msg) => (
        <div key={msg.id}>
          <strong>{msg.role}:</strong> {msg.content}
        </div>
      ))}

      {isStreaming && <button onClick={stop}>Stop</button>}

      <form onSubmit={(e) => {
        e.preventDefault()
        const input = e.currentTarget.elements.namedItem("msg") as HTMLInputElement
        sendMessage(input.value)
        input.value = ""
      }}>
        <input name="msg" placeholder="Send a message..." />
      </form>
    </div>
  )
}

const client = new Superserve({
  apiKey: "your-api-key",     // required
  baseUrl: "https://...",     // default: https://api.superserve.ai
  timeout: 30000,             // ms, default: 30000
})

import { APIError, SuperserveError } from "@superserve/sdk"

try {
  await client.run("my-agent", { message: "Hello" })
} catch (e) {
  if (e instanceof APIError) {
    console.error(e.status)   // HTTP status code (401, 404, 500, etc.)
    console.error(e.message)  // Error message from the API
    console.error(e.details)  // Field-level error details, if any
  }

  if (e instanceof SuperserveError) {
    // Covers APIError and other SDK errors (e.g. aborted requests)
    console.error(e.message)
  }
}

import type {
  SuperserveOptions,
  RunOptions,
  StreamOptions,
  SessionOptions,
  RunResult,
  ToolCall,
  StreamEvent,
  TextEvent,
  ToolStartEvent,
  ToolEndEvent,
  RunCompletedEvent,
  RunFailedEvent,
  Agent,
  SessionInfo,
} from "@superserve/sdk"

import type {
  Message,
  AgentStatus,
  UseAgentOptions,
  UseAgentReturn,
  SuperserveProviderProps,
} from "@superserve/sdk/react"