SDK Reference

go get github.com/TenkiCloud/tenki-sdk-go/sandbox

npm install @tenkicloud/sandbox

pip install tenki-sandbox

import tenkisandbox "github.com/TenkiCloud/tenki-sdk-go/sandbox"

// Zero-config: reads TENKI_API_KEY and TENKI_API_URL.
client, err := tenkisandbox.New()

// Explicit:
client, err := tenkisandbox.New(
  tenkisandbox.WithAuthToken("tk_your_api_key"),
  tenkisandbox.WithBaseURL("https://api.example.com"),
)
defer client.Close()

import { TenkiSandbox } from "@tenkicloud/sandbox";

const sandbox = new TenkiSandbox(); // env-driven

// Or explicit:
const sandbox = new TenkiSandbox({
  authToken: "tk_...",
  baseUrl: "https://api.tenki.cloud",
});

from tenki_sandbox import Client, Sandbox

# Resource client, env-driven (reads TENKI_API_KEY and TENKI_API_ENDPOINT).
client = Client()

# Or explicit:
client = Client(
    auth_token="tk_your_api_key",
    base_url="https://api.tenki.cloud",
)

# Create and drive a session directly. `Sandbox.create` waits for RUNNING by
# default and doubles as a context manager that terminates on exit.
with Sandbox.create(name="demo", cpu_cores=2, memory_mb=4096) as sb:
    result = sb.exec("python3", "-c", "print('hello')")
    print(result.stdout_text)

identity, err := client.WhoAmI(ctx)
fmt.Printf("owner: %s/%s\n", identity.OwnerType, identity.OwnerID)
for _, ws := range identity.Workspaces {
  fmt.Printf("workspace: %s (%s)\n", ws.Name, ws.ID)
}

identity = client.who_am_i()
print(f"owner: {identity.owner_type}/{identity.owner_id}")
for ws in identity.workspaces:
    print(f"workspace: {ws.name} ({ws.id})")

result, err := session.OpenCode.Run(
  ctx,
  "Review this repository and summarize risks.",
  tenkisandbox.WithModel("anthropic/claude-sonnet-4-5"),
  tenkisandbox.WithTimeout(5*time.Minute),
  tenkisandbox.WithOnEvent(func(ev tenkisandbox.Event) {
    log.Printf("[%s] %s", ev.Type, ev.Data)
  }),
)

const run = await session.openCode.run("Fix the failing tests", {
  model: "claude-sonnet-4-20250514",
  onEvent: (e) => console.log(`[${e.type}] ${e.data}`),
});
console.log(`Cost: $${run.totalCost}`);

run = sb.opencode.run(
    "Review this repository and summarize risks.",
    model="anthropic/claude-sonnet-4-5",
    timeout=300,
    on_event=lambda ev: print(f"[{ev.kind}] {ev.data}"),
)
print(f"Cost: ${run.total_cost}")

instance, err := session.OpenCode.StartInstance(
  ctx,
  tenkisandbox.WithInstanceWorkDir("/workspace/repo"),
  tenkisandbox.WithInstanceModel("anthropic/claude-sonnet-4-5"),
)

result, err := instance.Run(ctx, "Fix the failing tests")

const instance = await session.openCode.startInstance({
  workDir: "/workspace",
  model: "claude-sonnet-4-20250514",
});
const result = await instance.run("Add unit tests");

instance = sb.opencode.start_instance(
    "/workspace/repo",
    model="anthropic/claude-sonnet-4-5",
)
result = instance.run("Fix the failing tests")

err = session.OpenCode.Abort(ctx)

out, err := session.Git.Clone(ctx, "https://github.com/octocat/Hello-World.git", tenkisandbox.GitCloneParams{
  Directory: "/workspace/repo",
  Depth:     1,
})
out, err = session.Git.Checkout(ctx, "main", tenkisandbox.GitCheckoutParams{})
out, err = session.Git.FetchPR(ctx, 123, tenkisandbox.GitFetchPRParams{
  Directory: "/workspace/repo",
})

await session.git.clone("https://github.com/org/repo", { depth: 1 });
await session.git.checkout("feature");
const diff = await session.git.diff({});
const log = await session.git.log({ maxCount: 10 });
await session.git.fetchPR(42, { remote: "origin" });

sb.git.clone("https://github.com/octocat/Hello-World.git", depth=1, directory="/workspace/repo")
sb.git.checkout("main")
diff = sb.git.diff()
log = sb.git.log(max_count=10)
sb.git.fetch_pr(123, directory="/workspace/repo")

import { GB, GiB, KB, KiB, MB, MiB, TB, TiB } from "@tenkicloud/sandbox";

const tenGiB = 10 * GiB;

from tenki_sandbox import GB, GiB, KB, KiB, MB, MiB, TB, TiB

ten_gib = 10 * GiB

if errors.Is(err, tenkisandbox.ErrSnapshotFailed) {
  // inspect the snapshot record and recreate
}

import { CommandTimeoutError, QuotaExceededError, SessionNotFoundError } from "@tenkicloud/sandbox";

try {
  await session.exec("sleep", { args: ["999"], timeoutMs: 1000 });
} catch (err) {
  if (err instanceof CommandTimeoutError) {
    console.log("Command timed out");
  }
}

from tenki_sandbox import CommandTimeoutError, QuotaExceededError, SessionNotFoundError

try:
    sb.exec("sleep", "999", timeout=1)
except CommandTimeoutError:
    print("Command timed out")