MyApp

CreateDecision

Decisions API (OpenRouter)

The following routes are available for this service:
POST	/v1/decisions

import 'package:servicestack/servicestack.dart';

// @DataContract
class DecisionAnswer implements IConvertible
{
    // @DataMember(Name="type")
    String type = "";

    /**
    * noul: probability from 0 (no) to 1 (yes)
    */
    // @DataMember(Name="noul")
    double? noul;

    /**
    * choice: the selected option
    */
    // @DataMember(Name="choice")
    String? choice;

    /**
    * score: position on the scale, 0 = first description
    */
    // @DataMember(Name="score")
    double? score;

    // @DataMember(Name="confidence")
    double? confidence;

    /**
    * choice/score: probability of each option (score options are "0", "1", ...)
    */
    // @DataMember(Name="probabilities")
    Map<String,double?>? probabilities;

    /**
    * score: description of each scale position
    */
    // @DataMember(Name="legend")
    Map<String,String?>? legend;

    DecisionAnswer({this.type="",this.noul,this.choice,this.score,this.confidence,this.probabilities,this.legend});
    DecisionAnswer.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = json['type'] ?? "";
        noul = JsonConverters.toDouble(json['noul']);
        choice = json['choice'];
        score = JsonConverters.toDouble(json['score']);
        confidence = JsonConverters.toDouble(json['confidence']);
        probabilities = JsonConverters.fromJson(json['probabilities'],'Map<String,double?>',context!);
        legend = JsonConverters.toStringMap(json['legend']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': type,
        'noul': noul,
        'choice': choice,
        'score': score,
        'confidence': confidence,
        'probabilities': JsonConverters.toJson(probabilities,'Map<String,double?>',context!),
        'legend': legend
    };

    getTypeName() => "DecisionAnswer";
    TypeContext? context = _ctx;
}

// @DataContract
class DecisionUsage implements IConvertible
{
    // @DataMember(Name="input_tokens")
    int input_tokens = 0;

    // @DataMember(Name="output_tokens")
    int output_tokens = 0;

    // @DataMember(Name="cost")
    double? cost;

    DecisionUsage({this.input_tokens=0,this.output_tokens=0,this.cost});
    DecisionUsage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        input_tokens = json['inputTokens'] ?? 0;
        output_tokens = json['outputTokens'] ?? 0;
        cost = JsonConverters.toDouble(json['cost']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'input_tokens': input_tokens,
        'output_tokens': output_tokens,
        'cost': cost
    };

    getTypeName() => "DecisionUsage";
    TypeContext? context = _ctx;
}

// @DataContract
class DecisionResponse implements IConvertible
{
    // @DataMember(Name="id")
    String? id;

    // @DataMember(Name="model")
    String model = "";

    // @DataMember(Name="provider")
    String? provider;

    /**
    * Answers by question name, validated against the submitted questions
    */
    // @DataMember(Name="answers")
    Map<String,DecisionAnswer?> answers = {};

    // @DataMember(Name="usage")
    DecisionUsage? usage;

    DecisionResponse({this.id,this.model="",this.provider,this.answers=const {},this.usage});
    DecisionResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        model = json['model'] ?? "";
        provider = json['provider'];
        answers = JsonConverters.fromJson(json['answers'],'Map<String,DecisionAnswer?>',context!) ?? {};
        usage = JsonConverters.fromJson(json['usage'],'DecisionUsage',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'model': model,
        'provider': provider,
        'answers': JsonConverters.toJson(answers,'Map<String,DecisionAnswer?>',context!),
        'usage': JsonConverters.toJson(usage,'DecisionUsage',context!)
    };

    getTypeName() => "DecisionResponse";
    TypeContext? context = _ctx;
}

// @DataContract
class DecisionQuestion implements IConvertible
{
    /**
    * noul, choice or score
    */
    // @DataMember(Name="type")
    String type = "";

    /**
    * What to decide: text, or a JSON object/array of guidance
    */
    // @DataMember(Name="instructions")
    dynamic? instructions;

    /**
    * noul: {true,false} descriptions; choice: {option: description}; score: ordered descriptions
    */
    // @DataMember(Name="criteria")
    dynamic? criteria;

    DecisionQuestion({this.type="",this.instructions,this.criteria});
    DecisionQuestion.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = json['type'] ?? "";
        instructions = JsonConverters.fromJson(json['instructions'],'dynamic',context!);
        criteria = JsonConverters.fromJson(json['criteria'],'dynamic',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': type,
        'instructions': JsonConverters.toJson(instructions,'dynamic',context!),
        'criteria': JsonConverters.toJson(criteria,'dynamic',context!)
    };

    getTypeName() => "DecisionQuestion";
    TypeContext? context = _ctx;
}

/**
* Decisions API (OpenRouter)
*/
// @DataContract
class CreateDecision implements IPost, IConvertible
{
    /**
    * The decision model, e.g. ~typesafe/jev-latest
    */
    // @DataMember(Name="model")
    String model = "";

    /**
    * The content to evaluate: a plain string, or a JSON object or array of related context
    */
    // @DataMember(Name="state")
    dynamic? state;

    /**
    * Named noul (yes/no probability), choice (one option) or score (ordered scale) questions
    */
    // @DataMember(Name="questions")
    Map<String,DecisionQuestion?> questions = {};

    /**
    * A unique identifier for grouping related requests
    */
    // @DataMember(Name="session_id")
    String? session_id;

    /**
    * End-user identifier sent to OpenRouter. Omitted unless you set it.
    */
    // @DataMember(Name="user")
    String? user;

    /**
    * OpenRouter provider routing preferences
    */
    // @DataMember(Name="provider")
    Map<String,dynamic?>? provider;

    CreateDecision({this.model="",this.state,this.questions=const {},this.session_id,this.user,this.provider});
    CreateDecision.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        model = json['model'] ?? "";
        state = JsonConverters.fromJson(json['state'],'dynamic',context!);
        questions = JsonConverters.fromJson(json['questions'],'Map<String,DecisionQuestion?>',context!) ?? {};
        session_id = json['sessionId'];
        user = json['user'];
        provider = JsonConverters.fromJson(json['provider'],'Map<String,dynamic?>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'model': model,
        'state': JsonConverters.toJson(state,'dynamic',context!),
        'questions': JsonConverters.toJson(questions,'Map<String,DecisionQuestion?>',context!),
        'session_id': session_id,
        'user': user,
        'provider': JsonConverters.toJson(provider,'Map<String,dynamic?>',context!)
    };

    getTypeName() => "CreateDecision";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'vue_spa.web_templates.io', types: <String, TypeInfo> {
    'DecisionAnswer': TypeInfo(TypeOf.Class, create:() => DecisionAnswer()),
    'Map<String,double?>': TypeInfo(TypeOf.Class, create:() => Map<String,double?>()),
    'DecisionUsage': TypeInfo(TypeOf.Class, create:() => DecisionUsage()),
    'DecisionResponse': TypeInfo(TypeOf.Class, create:() => DecisionResponse()),
    'Map<String,DecisionAnswer?>': TypeInfo(TypeOf.Class, create:() => Map<String,DecisionAnswer?>()),
    'DecisionQuestion': TypeInfo(TypeOf.Class, create:() => DecisionQuestion()),
    'CreateDecision': TypeInfo(TypeOf.Class, create:() => CreateDecision()),
    'Map<String,DecisionQuestion?>': TypeInfo(TypeOf.Class, create:() => Map<String,DecisionQuestion?>()),
    'Map<String,dynamic?>': TypeInfo(TypeOf.Class, create:() => Map<String,dynamic?>()),
});

Dart CreateDecision DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .json suffix or ?format=json

To embed the response in a jsonp callback, append ?callback=myCallback

HTTP + JSON

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /v1/decisions HTTP/1.1 
Host: vue-spa.web-templates.io 
Accept: application/json
Content-Type: application/json
Content-Length: length

{"model":"String","state":{},"questions":{"String":{"type":"String","instructions":{},"criteria":{}}},"session_id":"String","user":"String","provider":{"String":{}}}

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: length

{"id":"String","model":"String","provider":"String","answers":{"String":{"type":"String","noul":0,"choice":"String","score":0,"confidence":0,"probabilities":{"String":0},"legend":{"String":"String"}}},"usage":{"input_tokens":0,"output_tokens":0,"cost":0}}