Quickstart

python -m pip install gmi-agentbox-sdk

go get github.com/GMISWE/agentbox-sdk-go

import time

from agentbox_sdk import AgentBoxClient, SandboxFailed, SandboxWaitTimeout

client = AgentBoxClient()  # reads GMI_AGENTBOX_API_KEY

# Available values vary by organization.
idcs = client.idcs.list(runtime="sandbox")
idc_id = "us-central-iowa16"  # choose an idc_id returned above
products = client.products.list(idc_name=idc_id, runtime="sandbox")
instance_type = "gmi.sandbox.small"  # choose an instance_type returned above


def wait_for_template(agent, timeout=600, poll_interval=3):
    deadline = time.monotonic() + timeout
    while True:
        agent.refresh()
        status = agent.template_build_status
        if status == "ready" or status is None:
            return
        if status == "error":
            raise RuntimeError(agent.template_build_error or "Sandbox image build failed")
        if time.monotonic() >= deadline:
            raise TimeoutError(f"Sandbox image is still {status!r} after {timeout}s")
        time.sleep(poll_interval)


agent = None
sandbox = None
try:
    agent = client.agents.create(
        title="agentbox-demo",  # choose a unique name
        image_url="docker.io/library/alpine:3.20",
        idc=idc_id,
        instance_type=instance_type,
        runtime="sandbox",
    )
    wait_for_template(agent)  # a new image can take several minutes

    sandbox = agent.launch(instance_type=instance_type)
    sandbox.wait_until_running()  # default timeout 300s

    execution = sandbox.execute("echo hello")
    print(execution.status, execution.exit_code, execution.data.get("stdout"))
except SandboxFailed as exc:
    print("failed", exc.status, exc.message)
except SandboxWaitTimeout:
    print("still not running", sandbox.status, sandbox.last_error)
finally:
    if sandbox is not None:
        sandbox.delete()
    if agent is not None:
        agent.delete()

package main

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/GMISWE/agentbox-sdk-go/agentbox"
)

func waitForTemplate(ctx context.Context, agent *agentbox.Agent, timeout, pollInterval time.Duration) error {
	deadline := time.Now().Add(timeout)
	for {
		if err := agent.Refresh(ctx); err != nil {
			return err
		}
		status := agent.TemplateBuildStatus()
		if status == "ready" || status == "" {
			return nil
		}
		if status == "error" {
			msg := agent.TemplateBuildError()
			if msg == "" {
				msg = "Sandbox image build failed"
			}
			return errors.New(msg)
		}
		if time.Now().After(deadline) {
			return fmt.Errorf("Sandbox image is still %q after %s", status, timeout)
		}
		time.Sleep(pollInterval)
	}
}

func main() {
	ctx := context.Background()
	client, err := agentbox.NewClient() // reads GMI_AGENTBOX_API_KEY
	if err != nil {
		panic(err)
	}

	// Available values vary by organization.
	idcs, err := client.Idcs.List(ctx, "sandbox")
	if err != nil {
		panic(err)
	}
	_ = idcs
	idcID := "us-central-iowa16" // choose an idc_id returned above
	products, err := client.Products.List(ctx, agentbox.ProductListParams{IdcName: idcID, Runtime: "sandbox"})
	if err != nil {
		panic(err)
	}
	_ = products
	instanceType := "gmi.sandbox.small" // choose an instance_type returned above

	var agent *agentbox.Agent
	var sandbox *agentbox.Sandbox
	defer func() {
		if sandbox != nil {
			sandbox.Delete(ctx)
		}
		if agent != nil {
			agent.Delete(ctx)
		}
	}()

	agent, err = client.Agents.Create(ctx, agentbox.AgentCreateParams{
		Title:        "agentbox-demo", // choose a unique name
		ImageURL:     "docker.io/library/alpine:3.20",
		Idc:          idcID,
		InstanceType: instanceType,
		Runtime:      "sandbox",
	})
	if err != nil {
		panic(err)
	}
	if err := waitForTemplate(ctx, agent, 600*time.Second, 3*time.Second); err != nil {
		panic(err)
	}

	sandbox, err = agent.Launch(ctx, agentbox.LaunchParams{InstanceType: instanceType})
	if err != nil {
		panic(err)
	}
	if err := sandbox.WaitUntilRunning(ctx, agentbox.WaitUntilRunningParams{}); err != nil {
		panic(err)
	}

	execution, err := sandbox.Execute(ctx, "echo hello", agentbox.ExecuteParams{})
	if err != nil {
		panic(err)
	}
	fmt.Println(execution.Status(), execution.Data["stdout"])
	if code := execution.ExitCode(); code != nil { // nil until the command finishes
		fmt.Println("exit code:", *code)
	}
}