# Register ruleset

POST https://api.forboc.ai/rules
Content-Type: application/json

Registers a directive ruleset for protocol synthesis.

Reference: https://docs.forboc.ai/api-reference/endpoints/forboc-ai-sdk-api/rules/register-ruleset

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: ForbocAI API
  version: 1.0.0
paths:
  /rules:
    post:
      operationId: register-ruleset
      summary: Register ruleset
      description: Registers a directive ruleset for protocol synthesis.
      tags:
        - subpackage_rules
      parameters:
        - name: Authorization
          in: header
          description: Bearer authentication
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Successful response
        '403':
          description: Ruleset registration is disabled (static law)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/DirectiveRuleSet'
servers:
  - url: https://api.forboc.ai
  - url: http://localhost:8080
components:
  schemas:
    DirectiveRule:
      type: object
      properties:
        drRuleId:
          type: string
        ruleName:
          type: string
        ruleCondition:
          type: array
          items:
            type: array
            items:
              type: string
          description: Key-value condition pairs
        ruleAction:
          type: string
        ruleReason:
          type: string
        ruleTarget:
          type:
            - string
            - 'null'
        rulePriority:
          type: integer
        ruleObsPattern:
          type:
            - string
            - 'null'
        rulePromptSuffix:
          type:
            - string
            - 'null'
      title: DirectiveRule
    DirectiveRuleSetTemplate:
      type: string
      enum:
        - Raw
        - ChatML
        - Llama3
        - Alpaca
      title: DirectiveRuleSetTemplate
    DirectiveRuleSet:
      type: object
      properties:
        rulesetId:
          type: string
        rulesetRules:
          type: array
          items:
            $ref: '#/components/schemas/DirectiveRule'
        template:
          oneOf:
            - $ref: '#/components/schemas/DirectiveRuleSetTemplate'
            - type: 'null'
      title: DirectiveRuleSet
    ErrorResponse:
      type: object
      properties:
        error:
          type: string
      title: ErrorResponse
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer

```

## SDK Code Examples

```python
import requests

url = "https://api.forboc.ai/rules"

payload = {
    "rulesetId": "protocol_synthesis_v1",
    "rulesetRules": [
        {
            "drRuleId": "rule_001",
            "ruleName": "Identify Actor",
            "ruleCondition": [["eventType", "observation"], ["priority", "high"]],
            "ruleAction": "IdentifyActor",
            "ruleReason": "Must identify the actor from the observation event",
            "ruleTarget": "npcId",
            "rulePriority": 10,
            "ruleObsPattern": "event.actor != null",
            "rulePromptSuffix": "Focus on actor identification."
        },
        {
            "drRuleId": "rule_002",
            "ruleName": "Query Vector DB",
            "ruleCondition": [["instruction", "QueryVector"], ["memoryState", "stale"]],
            "ruleAction": "QueryVector",
            "ruleReason": "Retrieve relevant memory vectors for inference",
            "rulePriority": 8,
            "rulePromptSuffix": "Retrieve relevant memories."
        },
        {
            "drRuleId": "rule_003",
            "ruleName": "Execute Inference",
            "ruleCondition": [["instruction", "ExecuteInference"]],
            "ruleAction": "ExecuteInference",
            "ruleReason": "Perform inference based on current tape and memory",
            "rulePriority": 7,
            "rulePromptSuffix": "Run inference engine."
        },
        {
            "drRuleId": "rule_004",
            "ruleName": "Finalize Protocol",
            "ruleCondition": [["instruction", "Finalize"]],
            "ruleAction": "Finalize",
            "ruleReason": "Complete the protocol and update state",
            "rulePriority": 5,
            "rulePromptSuffix": "Finalize and update state."
        }
    ],
    "template": "ChatML"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.forboc.ai/rules';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"rulesetId":"protocol_synthesis_v1","rulesetRules":[{"drRuleId":"rule_001","ruleName":"Identify Actor","ruleCondition":[["eventType","observation"],["priority","high"]],"ruleAction":"IdentifyActor","ruleReason":"Must identify the actor from the observation event","ruleTarget":"npcId","rulePriority":10,"ruleObsPattern":"event.actor != null","rulePromptSuffix":"Focus on actor identification."},{"drRuleId":"rule_002","ruleName":"Query Vector DB","ruleCondition":[["instruction","QueryVector"],["memoryState","stale"]],"ruleAction":"QueryVector","ruleReason":"Retrieve relevant memory vectors for inference","rulePriority":8,"rulePromptSuffix":"Retrieve relevant memories."},{"drRuleId":"rule_003","ruleName":"Execute Inference","ruleCondition":[["instruction","ExecuteInference"]],"ruleAction":"ExecuteInference","ruleReason":"Perform inference based on current tape and memory","rulePriority":7,"rulePromptSuffix":"Run inference engine."},{"drRuleId":"rule_004","ruleName":"Finalize Protocol","ruleCondition":[["instruction","Finalize"]],"ruleAction":"Finalize","ruleReason":"Complete the protocol and update state","rulePriority":5,"rulePromptSuffix":"Finalize and update state."}],"template":"ChatML"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.forboc.ai/rules"

	payload := strings.NewReader("{\n  \"rulesetId\": \"protocol_synthesis_v1\",\n  \"rulesetRules\": [\n    {\n      \"drRuleId\": \"rule_001\",\n      \"ruleName\": \"Identify Actor\",\n      \"ruleCondition\": [\n        [\n          \"eventType\",\n          \"observation\"\n        ],\n        [\n          \"priority\",\n          \"high\"\n        ]\n      ],\n      \"ruleAction\": \"IdentifyActor\",\n      \"ruleReason\": \"Must identify the actor from the observation event\",\n      \"ruleTarget\": \"npcId\",\n      \"rulePriority\": 10,\n      \"ruleObsPattern\": \"event.actor != null\",\n      \"rulePromptSuffix\": \"Focus on actor identification.\"\n    },\n    {\n      \"drRuleId\": \"rule_002\",\n      \"ruleName\": \"Query Vector DB\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"QueryVector\"\n        ],\n        [\n          \"memoryState\",\n          \"stale\"\n        ]\n      ],\n      \"ruleAction\": \"QueryVector\",\n      \"ruleReason\": \"Retrieve relevant memory vectors for inference\",\n      \"rulePriority\": 8,\n      \"rulePromptSuffix\": \"Retrieve relevant memories.\"\n    },\n    {\n      \"drRuleId\": \"rule_003\",\n      \"ruleName\": \"Execute Inference\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"ExecuteInference\"\n        ]\n      ],\n      \"ruleAction\": \"ExecuteInference\",\n      \"ruleReason\": \"Perform inference based on current tape and memory\",\n      \"rulePriority\": 7,\n      \"rulePromptSuffix\": \"Run inference engine.\"\n    },\n    {\n      \"drRuleId\": \"rule_004\",\n      \"ruleName\": \"Finalize Protocol\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"Finalize\"\n        ]\n      ],\n      \"ruleAction\": \"Finalize\",\n      \"ruleReason\": \"Complete the protocol and update state\",\n      \"rulePriority\": 5,\n      \"rulePromptSuffix\": \"Finalize and update state.\"\n    }\n  ],\n  \"template\": \"ChatML\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.forboc.ai/rules")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"rulesetId\": \"protocol_synthesis_v1\",\n  \"rulesetRules\": [\n    {\n      \"drRuleId\": \"rule_001\",\n      \"ruleName\": \"Identify Actor\",\n      \"ruleCondition\": [\n        [\n          \"eventType\",\n          \"observation\"\n        ],\n        [\n          \"priority\",\n          \"high\"\n        ]\n      ],\n      \"ruleAction\": \"IdentifyActor\",\n      \"ruleReason\": \"Must identify the actor from the observation event\",\n      \"ruleTarget\": \"npcId\",\n      \"rulePriority\": 10,\n      \"ruleObsPattern\": \"event.actor != null\",\n      \"rulePromptSuffix\": \"Focus on actor identification.\"\n    },\n    {\n      \"drRuleId\": \"rule_002\",\n      \"ruleName\": \"Query Vector DB\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"QueryVector\"\n        ],\n        [\n          \"memoryState\",\n          \"stale\"\n        ]\n      ],\n      \"ruleAction\": \"QueryVector\",\n      \"ruleReason\": \"Retrieve relevant memory vectors for inference\",\n      \"rulePriority\": 8,\n      \"rulePromptSuffix\": \"Retrieve relevant memories.\"\n    },\n    {\n      \"drRuleId\": \"rule_003\",\n      \"ruleName\": \"Execute Inference\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"ExecuteInference\"\n        ]\n      ],\n      \"ruleAction\": \"ExecuteInference\",\n      \"ruleReason\": \"Perform inference based on current tape and memory\",\n      \"rulePriority\": 7,\n      \"rulePromptSuffix\": \"Run inference engine.\"\n    },\n    {\n      \"drRuleId\": \"rule_004\",\n      \"ruleName\": \"Finalize Protocol\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"Finalize\"\n        ]\n      ],\n      \"ruleAction\": \"Finalize\",\n      \"ruleReason\": \"Complete the protocol and update state\",\n      \"rulePriority\": 5,\n      \"rulePromptSuffix\": \"Finalize and update state.\"\n    }\n  ],\n  \"template\": \"ChatML\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.forboc.ai/rules")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"rulesetId\": \"protocol_synthesis_v1\",\n  \"rulesetRules\": [\n    {\n      \"drRuleId\": \"rule_001\",\n      \"ruleName\": \"Identify Actor\",\n      \"ruleCondition\": [\n        [\n          \"eventType\",\n          \"observation\"\n        ],\n        [\n          \"priority\",\n          \"high\"\n        ]\n      ],\n      \"ruleAction\": \"IdentifyActor\",\n      \"ruleReason\": \"Must identify the actor from the observation event\",\n      \"ruleTarget\": \"npcId\",\n      \"rulePriority\": 10,\n      \"ruleObsPattern\": \"event.actor != null\",\n      \"rulePromptSuffix\": \"Focus on actor identification.\"\n    },\n    {\n      \"drRuleId\": \"rule_002\",\n      \"ruleName\": \"Query Vector DB\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"QueryVector\"\n        ],\n        [\n          \"memoryState\",\n          \"stale\"\n        ]\n      ],\n      \"ruleAction\": \"QueryVector\",\n      \"ruleReason\": \"Retrieve relevant memory vectors for inference\",\n      \"rulePriority\": 8,\n      \"rulePromptSuffix\": \"Retrieve relevant memories.\"\n    },\n    {\n      \"drRuleId\": \"rule_003\",\n      \"ruleName\": \"Execute Inference\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"ExecuteInference\"\n        ]\n      ],\n      \"ruleAction\": \"ExecuteInference\",\n      \"ruleReason\": \"Perform inference based on current tape and memory\",\n      \"rulePriority\": 7,\n      \"rulePromptSuffix\": \"Run inference engine.\"\n    },\n    {\n      \"drRuleId\": \"rule_004\",\n      \"ruleName\": \"Finalize Protocol\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"Finalize\"\n        ]\n      ],\n      \"ruleAction\": \"Finalize\",\n      \"ruleReason\": \"Complete the protocol and update state\",\n      \"rulePriority\": 5,\n      \"rulePromptSuffix\": \"Finalize and update state.\"\n    }\n  ],\n  \"template\": \"ChatML\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.forboc.ai/rules', [
  'body' => '{
  "rulesetId": "protocol_synthesis_v1",
  "rulesetRules": [
    {
      "drRuleId": "rule_001",
      "ruleName": "Identify Actor",
      "ruleCondition": [
        [
          "eventType",
          "observation"
        ],
        [
          "priority",
          "high"
        ]
      ],
      "ruleAction": "IdentifyActor",
      "ruleReason": "Must identify the actor from the observation event",
      "ruleTarget": "npcId",
      "rulePriority": 10,
      "ruleObsPattern": "event.actor != null",
      "rulePromptSuffix": "Focus on actor identification."
    },
    {
      "drRuleId": "rule_002",
      "ruleName": "Query Vector DB",
      "ruleCondition": [
        [
          "instruction",
          "QueryVector"
        ],
        [
          "memoryState",
          "stale"
        ]
      ],
      "ruleAction": "QueryVector",
      "ruleReason": "Retrieve relevant memory vectors for inference",
      "rulePriority": 8,
      "rulePromptSuffix": "Retrieve relevant memories."
    },
    {
      "drRuleId": "rule_003",
      "ruleName": "Execute Inference",
      "ruleCondition": [
        [
          "instruction",
          "ExecuteInference"
        ]
      ],
      "ruleAction": "ExecuteInference",
      "ruleReason": "Perform inference based on current tape and memory",
      "rulePriority": 7,
      "rulePromptSuffix": "Run inference engine."
    },
    {
      "drRuleId": "rule_004",
      "ruleName": "Finalize Protocol",
      "ruleCondition": [
        [
          "instruction",
          "Finalize"
        ]
      ],
      "ruleAction": "Finalize",
      "ruleReason": "Complete the protocol and update state",
      "rulePriority": 5,
      "rulePromptSuffix": "Finalize and update state."
    }
  ],
  "template": "ChatML"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.forboc.ai/rules");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"rulesetId\": \"protocol_synthesis_v1\",\n  \"rulesetRules\": [\n    {\n      \"drRuleId\": \"rule_001\",\n      \"ruleName\": \"Identify Actor\",\n      \"ruleCondition\": [\n        [\n          \"eventType\",\n          \"observation\"\n        ],\n        [\n          \"priority\",\n          \"high\"\n        ]\n      ],\n      \"ruleAction\": \"IdentifyActor\",\n      \"ruleReason\": \"Must identify the actor from the observation event\",\n      \"ruleTarget\": \"npcId\",\n      \"rulePriority\": 10,\n      \"ruleObsPattern\": \"event.actor != null\",\n      \"rulePromptSuffix\": \"Focus on actor identification.\"\n    },\n    {\n      \"drRuleId\": \"rule_002\",\n      \"ruleName\": \"Query Vector DB\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"QueryVector\"\n        ],\n        [\n          \"memoryState\",\n          \"stale\"\n        ]\n      ],\n      \"ruleAction\": \"QueryVector\",\n      \"ruleReason\": \"Retrieve relevant memory vectors for inference\",\n      \"rulePriority\": 8,\n      \"rulePromptSuffix\": \"Retrieve relevant memories.\"\n    },\n    {\n      \"drRuleId\": \"rule_003\",\n      \"ruleName\": \"Execute Inference\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"ExecuteInference\"\n        ]\n      ],\n      \"ruleAction\": \"ExecuteInference\",\n      \"ruleReason\": \"Perform inference based on current tape and memory\",\n      \"rulePriority\": 7,\n      \"rulePromptSuffix\": \"Run inference engine.\"\n    },\n    {\n      \"drRuleId\": \"rule_004\",\n      \"ruleName\": \"Finalize Protocol\",\n      \"ruleCondition\": [\n        [\n          \"instruction\",\n          \"Finalize\"\n        ]\n      ],\n      \"ruleAction\": \"Finalize\",\n      \"ruleReason\": \"Complete the protocol and update state\",\n      \"rulePriority\": 5,\n      \"rulePromptSuffix\": \"Finalize and update state.\"\n    }\n  ],\n  \"template\": \"ChatML\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "rulesetId": "protocol_synthesis_v1",
  "rulesetRules": [
    [
      "drRuleId": "rule_001",
      "ruleName": "Identify Actor",
      "ruleCondition": [["eventType", "observation"], ["priority", "high"]],
      "ruleAction": "IdentifyActor",
      "ruleReason": "Must identify the actor from the observation event",
      "ruleTarget": "npcId",
      "rulePriority": 10,
      "ruleObsPattern": "event.actor != null",
      "rulePromptSuffix": "Focus on actor identification."
    ],
    [
      "drRuleId": "rule_002",
      "ruleName": "Query Vector DB",
      "ruleCondition": [["instruction", "QueryVector"], ["memoryState", "stale"]],
      "ruleAction": "QueryVector",
      "ruleReason": "Retrieve relevant memory vectors for inference",
      "rulePriority": 8,
      "rulePromptSuffix": "Retrieve relevant memories."
    ],
    [
      "drRuleId": "rule_003",
      "ruleName": "Execute Inference",
      "ruleCondition": [["instruction", "ExecuteInference"]],
      "ruleAction": "ExecuteInference",
      "ruleReason": "Perform inference based on current tape and memory",
      "rulePriority": 7,
      "rulePromptSuffix": "Run inference engine."
    ],
    [
      "drRuleId": "rule_004",
      "ruleName": "Finalize Protocol",
      "ruleCondition": [["instruction", "Finalize"]],
      "ruleAction": "Finalize",
      "ruleReason": "Complete the protocol and update state",
      "rulePriority": 5,
      "rulePromptSuffix": "Finalize and update state."
    ]
  ],
  "template": "ChatML"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.forboc.ai/rules")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```