Go

go get github.com/simular-ai/sai-sdk/go
export SAI_API_KEY="sapi_..."

import (
	"context"
	"fmt"
	"log"

	sai "github.com/simular-ai/sai-sdk/go"
)

ctx := context.Background()
client, err := sai.New(sai.Options{}) // SAI_API_KEY, and SAI_API_URL if set
if err != nil {
	log.Fatal(err)
}
machines, err := client.Machines.List(ctx)
if err != nil {
	log.Fatal(err)
}
pc := machines[0]

session, err := client.Sessions.Create(ctx, &sai.SessionOptions{Machine: pc.ID})
if err != nil {
	log.Fatal(err)
}
result, err := session.Run(ctx, "Open Notepad, type hello, save it to the desktop as hello.txt", nil)
if err != nil {
	log.Fatal(err)
}

fmt.Println(result.Status) // idle, needs_approval or error
fmt.Println(result.Text)   // Sai's answer
fmt.Println(result.Usage)  // tokens and cost of this task

turn, err := session.Send(ctx, "Find last month's invoices in Downloads and total them", nil)
if err != nil {
	log.Fatal(err)
}
for ev, err := range turn.Events(ctx, nil) {
	if err != nil {
		log.Fatal(err)
	}
	switch ev.Kind {
	case sai.EventStep:
		fmt.Println("  ", ev.Text)
	case sai.EventApproval:
		if _, err := turn.Respond(ctx, ev.Approval, "yes", nil); err != nil {
			log.Fatal(err)
		}
	}
}
result, err := turn.Wait(ctx, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println(result.Text)

result, err := session.Run(ctx, "Clean up the temp folder", &sai.RunOptions{
	OnApproval: func(a *sai.Approval) *sai.ApprovalAnswer {
		if a.IsLinkOnly {
			fmt.Println("Approve in a browser:", a.URL)
			return nil // a person answers it; keep waiting
		}
		if a.Type == "choice" {
			var selections [][]string
			for _, q := range a.Questions {
				first := q["options"].([]any)[0].(map[string]any)
				selections = append(selections, []string{first["value"].(string)})
			}
			return &sai.ApprovalAnswer{Response: "yes", Selections: selections}
		}
		return &sai.ApprovalAnswer{Response: "yes"}
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(result.Status)

if _, err := session.Run(ctx, "Export last month's invoices to CSV", &sai.RunOptions{Autonomous: true}); err != nil {
	log.Fatal(err)
}

import "os"

f, err := os.Open("report.pdf")
if err != nil {
	log.Fatal(err)
}
report, err := client.Files.Upload(ctx, "report.pdf", f) // any io.Reader, with the file's name
f.Close()
if err != nil {
	log.Fatal(err)
}
if _, err := session.Run(ctx, "Summarise the attached report", &sai.RunOptions{Attachments: []*sai.Attachment{report}}); err != nil {
	log.Fatal(err)
}

models, err := client.Models.List(ctx)
if err != nil {
	log.Fatal(err)
}
var allowed []string
for _, m := range models {
	if m.Allowed {
		allowed = append(allowed, m.ID)
	}
}
fmt.Println(allowed)
if _, err := session.Run(ctx, "...", &sai.RunOptions{Model: "anthropic/claude-opus-5-5"}); err != nil { // sticks to the session
	log.Fatal(err)
}

turn, err := session.Send(ctx, "...", nil)
if err != nil {
	log.Fatal(err)
}
if _, err := turn.Abort(ctx); err != nil {
	log.Fatal(err)
}

result, err := session.Run(ctx, "Open https://news.ycombinator.com and read the title of the top story.", &sai.RunOptions{
	OutputSchema: map[string]any{
		"type":       "object",
		"properties": map[string]any{"title": map[string]any{"type": "string"}},
		"required":   []string{"title"},
	},
})
if err != nil {
	log.Fatal(err)
}
if result.OK {
	fmt.Println(result.Record.Output.(map[string]any)["title"])
} else if result.Record != nil {
	fmt.Println(result.Record.ReasonCode) // e.g. output_invalid
}

turn, err := session.Send(ctx, "...", &sai.SendOptions{RecordTrajectory: true})
if err != nil {
	log.Fatal(err)
}
record, err := client.Turns.Wait(ctx, turn.ID) // until succeeded, failed or needs_input
if err != nil {
	log.Fatal(err)
}
fmt.Println(record.Status)
steps, err := client.Turns.Trajectory(ctx, turn.ID)
if err != nil {
	log.Fatal(err)
}
for _, step := range steps {
	fmt.Println(step.Index, step.Title)
}

turn, err := session.Send(ctx,
	"Open {{newsSite}}, find all {{topic}} news published today, write their headlines into Notepad, one per line, and save the file as {{fileName}}",
	&sai.SendOptions{
		Inputs:           map[string]any{"newsSite": "TechCrunch", "topic": "AI", "fileName": "techcrunch_headlines.txt"},
		RecordTrajectory: true,
	},
)
if err != nil {
	log.Fatal(err)
}
if _, err := client.Turns.Wait(ctx, turn.ID); err != nil {
	log.Fatal(err)
}

learned, err := client.Learn.Create(ctx, []string{turn.ID}, nil) // waits for the code; longer for a longer task
if err != nil {
	log.Fatal(err)
}
lease, err := client.Control.Open(ctx, pc.ID)
if err != nil {
	log.Fatal(err)
}
inputs := map[string]any{"newsSite": "TechCrunch", "topic": "Fintech", "fileName": "techcrunch_fintech.txt"}
r, err := lease.Run(ctx, learned, inputs, nil) // inputs over the defaults
if err != nil {
	log.Fatal(err)
}
fmt.Println(r.Result)
if err := lease.Close(ctx); err != nil {
	log.Fatal(err)
}

fixed, err := client.Learn.Create(ctx, nil, &sai.LearnOptions{
	InitialCode: learned.Code,
	Evaluations: []sai.Evaluation{{Inputs: inputs, Result: r, Passed: sai.Ptr(false)}},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(fixed.Changes)
judgement, err := client.Judge.Create(ctx,
	[]string{turn.ID},
	sai.Checks{{ID: "file", Check: "The agent saved the headlines to the file"}},
	nil,
)
if err != nil {
	log.Fatal(err)
}
fmt.Println(judgement.Verdict)

job, err := client.Learn.Create(ctx, nil, &sai.LearnOptions{
	TaskTemplate:  "Open {{newsSite}}, find all {{topic}} news published today, write their headlines into Notepad, one per line, and save the file as {{fileName}}",
	Inputs:        map[string]any{"newsSite": "TechCrunch", "topic": "AI", "fileName": "techcrunch_headlines.txt"},
	Machine:       pc.ID,
	Criteria:      sai.CriteriaText("techcrunch_headlines.txt is saved and holds, one per line, the headlines of the AI articles TechCrunch published today"),
	MaxIterations: 3, // up to 3 code versions; 0 (the default) only writes the code
	Rollouts:      3, // each version must pass 3 runs in a row
	Reset: &sai.ResetAction{Code: `for (const t of await machine.browser.listTabs()) await machine.browser.closeTab(t.tabId)
for (const w of await machine.getWindow("Notepad")) await w.close()`},
	ContinueWithAgent: true, // after a failed run, the agent finishes the task and the repair learns from it
})
if err != nil {
	log.Fatal(err)
}
done, err := client.Learn.Wait(ctx, job.ID, nil) // can take an hour; a context deadline stops waiting
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%s %s %+v\n", done.Status, done.StopReason, done.TestResult)
fmt.Println(done.Code) // the latest version
for _, it := range done.Iterations {
	var verdicts []string
	for _, r := range it.Rollouts {
		verdicts = append(verdicts, r.Verdict)
	}
	fmt.Println(it.Index, it.Changes, verdicts)
}

run, err := client.Learn.Rollout(ctx, job.ID, 1, 1) // what one run returned and logged, and its judgement
if err != nil {
	log.Fatal(err)
}
fmt.Println(run.Run)
if err := client.Learn.Cancel(ctx, job.ID); err != nil { // stops at once and keeps the last complete results
	log.Fatal(err)
}

import (
	"os"
	"strings"
)

lease, err := client.Control.Open(ctx, pc.ID)
if err != nil {
	log.Fatal(err)
}
defer lease.Close(ctx)

out, err := lease.Shell(ctx, "hostname", nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println(out.Stdout)

if err := lease.WriteFile(ctx, `C:\data\note.txt`, "hello"); err != nil {
	log.Fatal(err)
}
text, err := lease.ReadFile(ctx, `C:\data\note.txt`)
if err != nil {
	log.Fatal(err)
}
fmt.Println(text)

r, err := lease.Exec(ctx, `
	var page = await machine.browser.newtab('https://example.com')
	var snap = await page.snapshot()
	snap.title
`, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println(r.Result) // Example Domain

ext := strings.TrimPrefix(r.ScreenshotMimeType, "image/") // jpeg or png
if err := os.WriteFile("page."+ext, r.Screenshot, 0o644); err != nil {
	log.Fatal(err)
}

account, err := client.Account.Get(ctx) // plan and spendable credit
if err != nil {
	log.Fatal(err)
}
models, err := client.Models.List(ctx) // models, with Allowed for this plan
if err != nil {
	log.Fatal(err)
}
view, err := client.Machines.Live(ctx, pc.ID) // a link to the screen for a person, and a stream for your viewer; see Live view
if err != nil {
	log.Fatal(err)
}
revoked, err := client.Machines.RevokeLive(ctx, pc.ID) // every LiveURL stops working and its screen sessions end; returns how many
if err != nil {
	log.Fatal(err)
}
fmt.Println(account.PlanTitle, len(models), view.LiveURL, revoked)

me, err := client.Auth.Check(ctx) // the user, and the Tenant and Organisation for a Tenant token
if err != nil {
	log.Fatal(err)
}
sessions, err := client.Sessions.List(ctx, &sai.SessionOptions{Machine: pc.ID}) // your sessions on the computer, any channel, most recent first
if err != nil {
	log.Fatal(err)
}
fmt.Println(me.UserID, len(sessions))

view, err := client.Machines.Live(ctx, pc.ID)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Sign in here, then tell me:", view.LiveURL) // valid until view.ExpiresAt (ms)
// ... once they are done
if _, err := session.Run(ctx, "I signed in. Carry on.", nil); err != nil {
	log.Fatal(err)
}
if _, err := client.Machines.RevokeLive(ctx, pc.ID); err != nil { // returns the number of links revoked
	log.Fatal(err)
}

import (
	"context"
	"fmt"
	"log"
	"os"

	sai "github.com/simular-ai/sai-sdk/go"
)

ctx := context.Background()
org, err := sai.New(sai.Options{APIKey: os.Getenv("SAI_ORG_KEY"), OrgID: "org_3f9a1c0b7e2d4a6f8c10"})
if err != nil {
	log.Fatal(err)
}

tenant, err := org.Tenants.Create(ctx, "Riverside Clinic", &sai.TenantCreateOptions{ExternalID: "clinic-4821"})
if err != nil {
	log.Fatal(err)
}
enrollment, err := org.Tenants.CreateEnrollment(ctx, tenant.ID) // hand enrollment.Token to your installer
if err != nil {
	log.Fatal(err)
}
machines, err := org.TenantMachines.List(ctx, tenant.ID)
if err != nil {
	log.Fatal(err)
}
fmt.Println(enrollment.ExpiresAt, len(machines))

clinic, err := org.Tenants.Client(ctx, tenant.ID, nil) // acts as the Tenant
if err != nil {
	log.Fatal(err)
}
session, err := clinic.Sessions.Create(ctx, nil)
if err != nil {
	log.Fatal(err)
}
if _, err := session.Run(ctx, "Open the calendar and read today's appointments", nil); err != nil {
	log.Fatal(err)
}

import (
	"context"
	"fmt"
	"log"
	"os"

	sai "github.com/simular-ai/sai-sdk/go"
)

ctx := context.Background()
org, err := sai.New(sai.Options{APIKey: os.Getenv("SAI_ORG_KEY"), OrgID: "org_3f9a1c0b7e2d4a6f8c10"})
if err != nil {
	log.Fatal(err)
}

machine, err := org.TenantMachines.Create(ctx, "Xk2p9QzR4tLm8vNa3bCd", &sai.TenantMachineCreateOptions{
	OS:        "windows",
	Name:      "Riverside intake",
	RequestID: "riverside-intake-1", // send the same id again if you retry this create
	Wait:      true,
})
if err != nil {
	log.Fatal(err)
}
clinic, err := org.Tenants.Client(ctx, "Xk2p9QzR4tLm8vNa3bCd", nil)
if err != nil {
	log.Fatal(err)
}
session, err := clinic.Sessions.Create(ctx, &sai.SessionOptions{Machine: machine.ID})
if err != nil {
	log.Fatal(err)
}
if _, err := session.Run(ctx, "Open Notepad and type hello", nil); err != nil {
	log.Fatal(err)
}
state, err := org.TenantMachines.Delete(ctx, "Xk2p9QzR4tLm8vNa3bCd", machine.ID)
if err != nil {
	log.Fatal(err)
}
fmt.Println(state) // deleting

import (
	"context"
	"fmt"
	"log"
	"os"

	sai "github.com/simular-ai/sai-sdk/go"
)

ctx := context.Background()
org, err := sai.New(sai.Options{APIKey: os.Getenv("SAI_ORG_KEY"), OrgID: "org_3f9a1c0b7e2d4a6f8c10"})
if err != nil {
	log.Fatal(err)
}
usage, err := org.Usage.Get(ctx, &sai.UsageOptions{Granularity: "month", From: "2026-10", To: "2026-10"})
if err != nil {
	log.Fatal(err)
}
for _, t := range usage.Totals.ByTenant {
	fmt.Println(t.Name, t.CostCents)
}

page, err := org.Usage.Sessions(ctx, "Xk2p9QzR4tLm8vNa3bCd", &sai.UsageSessionsOptions{From: "2026-10-01", To: "2026-10-31"})
if err != nil {
	log.Fatal(err)
}
for _, s := range page.Sessions {
	if s.CostUSD != nil {
		fmt.Println(s.SessionID, *s.CostUSD)
	}
}

import "errors"

_, err := client.Machines.Get(ctx, "m_missing")
var notFound *sai.NotFoundError
if errors.As(err, &notFound) {
	fmt.Println(notFound.Status, notFound.Message) // 404
}
var saiErr *sai.SaiError
if errors.As(err, &saiErr) {
	fmt.Println(saiErr.Code, saiErr.RetryAfter)
}