Input Code — ตรวจข้อมูลก่อนใช้โมเดลValidate Inputs Before Spending Intelligence

1. The engineering problem

A model should not decide whether a JSON field is a string or whether a request body is too large. Those checks have exact answers. Start at the HTTP boundary with a byte limit, decoding rules and schema validation; then validate the domain values your application needs. The companion begins at an already-decoded Python object. It therefore demonstrates object validation, not a complete network ingress layer. A production endpoint must enforce its request-size limit before parsing an unbounded body.

input_check requires exactly id, issue, repo and action, all strings. The issue must contain between one and 4,000 UTF-8 bytes. Byte length matters because Thai and other non-ASCII text can use multiple bytes per character. This tutorial limit is chosen for a small issue, not copied from a vendor maximum. Rejecting unknown fields also prevents an attacker from slipping principal or approved=true into the application contract. Authentication remains the host application's responsibility.

2. The boundary to design

The lab replaces issue with the number 42 and observes input_type, state=reject, provider_calls=0. This is a stronger outcome than asking a model to apologize after processing the request. The test spies on the provider and confirms the pipeline stops. The same pattern applies to empty identifiers, huge messages and malformed objects. Ordinary type hints are useful documentation but do not validate a response arriving from a network or a user at runtime.

3. Read the implementation

Implementation excerpt from the companion. Run the complete lesson below with its imports and fixtures.

def input_check(raw):
    if not isinstance(raw, dict) or set(raw) != {"id", "issue", "repo", "action"}:
        return Gate("reject", "input_schema")
    if not all(isinstance(x, str) for x in raw.values()):
        return Gate("reject", "input_type")
    try:
        issue_bytes = raw["issue"].encode("utf-8")
    except UnicodeEncodeError:
        return Gate("reject", "input_encoding")
    if not 1 <= len(issue_bytes) <= 4000 or not raw["id"].strip():
        return Gate("reject", "input_size")
    return Gate("pass", "input_valid")

Be careful about normalization. Trimming whitespace or translating an issue changes the value being evaluated; retain the original identifier and record any transformation you apply. Secret handling needs its own control: minimize what gets sent, use reviewed redaction where appropriate, and do not log entire issues by default. A few regular expressions cannot guarantee detection of every credential. Separate exact validation failures from semantic review so users can repair malformed input without repeatedly invoking the model.

4. Compare the outcomes

The following output comes from scripted fixtures that verify architecture behavior. It is not a measurement of live Jev accuracy, latency, or cost.

{
  "state": "reject",
  "reason": "input_type",
  "provider_calls": 0
}

5. Run, break, and explain

Part 04 code · Implementation · Tests: test_input_stops_before_inference · Exercise

git clone https://github.com/Anirach/ai-core-engineering-workbench.git
cd ai-core-engineering-workbench
git checkout 18cdfcd4156d3d02acb8badf3b3a0a823113e0ed
python3 -m workbench.lesson 4
python3 -m unittest tests.test_boundaries.BoundaryTests.test_input_stops_before_inference -v

Your turn

Add a boundary case with Thai text and a byte length just above the limit. Confirm no provider call occurs.

Keep three artifacts: the input you tried, the resulting state and reason, and an explanation of which boundary owns that result. Do not change an expected result merely to make a test pass.

6. Sources and limits