Jev

# pip install hanzoai
import os

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import AiApi
from hanzoai.cloud.models.ai_decisions_request import AiDecisionsRequest

ai = AiApi(ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"])))

decision = ai.post_decisions(AiDecisionsRequest.from_dict({
    "model": "~typesafe/jev-latest",
    "state": {"incident": "checkout 5xx at 14%"},
    "questions": {
        "severity": {
            "type": "choice",
            "instructions": "How severe is this incident?",
            "criteria": {
                "low": "cosmetic or internal; no customer is affected",
                "high": "some customers are blocked from finishing a task",
                "critical": "every customer is blocked and no revenue comes in",
            },
        },
    },
}))

severity = decision.answers["severity"]
print(severity.choice, severity.probabilities)

curl -sS --fail-with-body https://api.hanzo.ai/v1/decisions \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "~typesafe/jev-latest",
    "state": { "incident": "checkout 5xx at 14%" },
    "questions": {
      "severity": {
        "type": "choice",
        "instructions": "How severe is this incident?",
        "criteria": {
          "low": "cosmetic or internal; no customer is affected",
          "high": "some customers are blocked from finishing a task",
          "critical": "every customer is blocked and no revenue comes in"
        }
      }
    }
  }'

// net/http: the Go SDK refuses a choice question with named criteria.
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func run() error {
	body, err := json.Marshal(map[string]any{
		"model": "~typesafe/jev-latest",
		"state": map[string]string{"incident": "checkout 5xx at 14%"},
		"questions": map[string]any{
			"severity": map[string]any{
				"type":         "choice",
				"instructions": "How severe is this incident?",
				"criteria": map[string]string{
					"low":      "cosmetic or internal; no customer is affected",
					"high":     "some customers are blocked from finishing a task",
					"critical": "every customer is blocked and no revenue comes in",
				},
			},
		},
	})
	if err != nil {
		return err
	}
	req, err := http.NewRequest("POST", "https://api.hanzo.ai/v1/decisions", bytes.NewReader(body))
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	out, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("HTTP %d: %s", resp.StatusCode, out)
	}

	var decision struct {
		Answers map[string]struct {
			Choice        string             `json:"choice"`
			Probabilities map[string]float64 `json:"probabilities"`
		} `json:"answers"`
	}
	if err := json.Unmarshal(out, &decision); err != nil {
		return err
	}
	severity := decision.Answers["severity"]
	fmt.Println(severity.Choice, severity.Probabilities)
	return nil
}