You can call the jev_decide MCP tool to evaluate supplied context and get typed judgments (choice, score, noul) from TypeSafe Jev, without executing actions.
Call jev_decide with state (relevant context, evidence, policies) and named questions.
Choose one of three decision types:
choice: select a label/candidate; returns selected choice, probabilities, and confidence.
score: rate a single dimension on 2–10 ordered levels; returns 0-based score, probabilities, legend, and confidence.
noul: judge whether a condition holds; returns probability of yes from 0 to 1.
Batch multiple independent questions over the same context in one call; answers retain their question IDs.
Provide context as a string, JSON object, or array containing facts, source text, and policies.
Optionally override the model per call; otherwise the configured default or jev-latest is used.
Receive structured MCP output plus JSON text with model, answers, and token usage.
Integrate the server with MCP hosts, e.g., Codex, via stdio, and use it with a TypeSafe API key.
A local stdio MCP server exposing one tool, jev_decide, for typed decisions through the official TypeSafe API. Written in TypeScript with the official MCP and TypeSafe SDKs.
Independent community project; not affiliated with TypeSafe. Licensed under MIT.
Question | Use it for | Result |
| Choose a label or candidate | Choice, probabilities, confidence |
| Rate a single dimension on 2–10 ordered levels | 0-based score, probabilities, legend, confidence |
| Judge whether a condition holds | Probability of yes, from 0 to 1 |
Batch independent questions over the same context in one call. Answers retain their question IDs. The MCP returns judgments and token usage; the caller owns thresholds, escalation, and action execution.
Requires Node.js 22 or newer. The published package runs without cloning or building:
npx -y jev-decision-mcp@0.1.2Set TYPESAFE_API_KEY in your MCP host's environment. For hosts that use
mcpServers JSON configuration:
{
"mcpServers": {
"jev": {
"command": "npx",
"args": ["-y", "jev-decision-mcp@0.1.2"]
}
}
}Node.js and npm must be installed and available on the host's PATH. If the
host cannot resolve npx, use its platform-specific launcher or absolute path
as documented by that host. GUI applications may have a different PATH from
your terminal.
The server communicates over stdio; starting it in a terminal waits for an MCP
client rather than opening a web page. The npm installation does not read a
.env from the caller's working directory.
Package: jev-decision-mcp on npm.
Related MCP server: Codex Gemini MCP
For the npm package, merge this into your Codex config.toml:
[mcp_servers.jev]
command = "npx"
args = ["-y", "jev-decision-mcp@0.1.2"]
env_vars = ["TYPESAFE_API_KEY"]
tool_timeout_sec = 45Set TYPESAFE_API_KEY in the environment that launches Codex; env_vars forwards
its existing value to the server. Keep the host tool timeout above
JEV_TIMEOUT_MS / 1000. See official Codex MCP configuration.
Requires Node.js 22 or newer.
git clone https://github.com/amidabuddha/jev-decision-mcp.git
cd jev-decision-mcp
npm ci
# Copy .env.example to .env and set TYPESAFE_API_KEY.
npm run buildObtain the key from TypeSafe Console. Use an official TypeSafe key, rather than an OpenRouter or third-party gateway key.
.env is excluded by .gitignore. The server reads the .env beside this README even when started from another working directory. Existing process environment variables take precedence. Restart the MCP server after editing .env.
Variable | Default | Purpose |
| Required for calls | TypeSafe API credential |
|
| Default model; each call can override it |
|
| Total deadline including retries; 1–120000 ms |
The server starts without a key so a host can discover the tool. Calls then return MISSING_API_KEY. API traffic is fixed to https://api.typesafe.ai/v1/systemone; TYPESAFE_BASE_URL does not override it. State and questions are sent to TypeSafe and may incur API charges. The server does not persist inputs or decisions and disables SDK logging. Upstream error bodies are not exposed because they may echo submitted data.
After building, configure your host to run node with the absolute path to
dist/index.js as its argument. For Codex, replace the npm example's command
with "node" and args with ["/absolute/path/to/jev-decision-mcp/dist/index.js"].
That path is a placeholder: use your own checkout path. In TOML or JSON, Windows
paths can use forward slashes, for example "C:/projects/jev-decision-mcp/dist/index.js".
If node is not on the host's PATH, use the absolute path to your Node executable.
The source build reads the repository's .env, so env_vars is only needed if
you supply the key through Codex's environment instead. For interactive local
development use npm run dev. No host configuration is modified by setup or tests.
Call jev_decide with the JSON in examples/decision.json. It combines a team choice, a refund yes/no judgment, and an urgency score. Smaller example:
{
"state": { "request": "Please refund the duplicate charge." },
"questions": {
"route": {
"type": "choice",
"instructions": "Which team should handle `request`?",
"criteria": {
"billing": "Charges, invoices, refunds",
"technical": "Broken software or integrations",
"other": "Neither billing nor technical"
}
}
}
}The response contains model, answers, and usage, both as MCP structured content and JSON text. Jev may round probabilities to two decimal places, so their sum can differ slightly from 1. The server allows the corresponding rounding margin (up to 0.005 per option) and preserves the returned values without normalization. Choice supports 1–255 named options. Instructions and descriptions may be strings, JSON objects, or arrays; choice descriptions may also be null. Noul accepts optional criteria.true and criteria.false descriptions.
Supply relevant facts, source text, and policies explicitly: Jev cannot see the caller's conversation or local files. Write complete judgments in instructions; IDs are only response keys. Include a no-match option when appropriate. Questions in one batch cannot see one another's answers. A noul near 0.5 is uncertainty about yes/no, not medium intensity. Confidence does not authorize actions or guarantee correctness; evaluate thresholds on representative data.
npm run check # Type checking + mocked API tests + real stdio MCP handshake
npm run test:live # Explicit live API call using only the synthetic example
npm run test:codex # Installed Codex schema parser + native MCP discovery, no model turn
# Add -- --live to test:codex to also call Jev through Codex's native MCP interface.Normal tests use synthetic credentials and mocked HTTP responses; they do not contact TypeSafe. Tests cover mixed decisions, input/output validation, missing keys, authentication errors, rate-limit retries, deadlines, cancellation, and MCP discovery/calls. The stdio smoke test starts from another working directory and checks that stdout remains valid MCP.
The live test requires your key, starts the built MCP server, calls jev_decide through an MCP client, validates the response, and prints judgments, elapsed time, and token usage. A passing live smoke test verifies integration, not general decision quality. SDK retries can make up to three HTTP attempts for transient failures, bounded by the total deadline.
test:codex requires the Codex CLI. It uses an ephemeral diagnostic context without starting a model turn. It verifies that Codex rejects the original tuple-style score schema, accepts the repaired array schema, and discovers the MCP tool. Passing generic MCP client tests alone does not establish Codex compatibility.
If an older session cannot see the tool after a server update, start a fresh task so it loads the rebuilt server. The MCP server is named jev and its tool is jev_decide; $Jev is not an installed skill.
Service/configuration failures are MCP tool errors (isError: true), never invented decisions. Codes include MISSING_API_KEY, INVALID_INPUT, INVALID_RESPONSE, API_ERROR, CONNECTION_ERROR, TIMEOUT, and CANCELLED. Invalid arguments may also be rejected directly by the MCP SDK.
Built using the typesafe-ai skill and official documentation, checked September 22, 2026:
jev-latest follows TypeSafe model updates. For repeatable evaluations, set a specific supported model version. SDK versions are recorded in package-lock.json.
Publishing a stable GitHub release triggers .github/workflows/publish-npm.yml.
The workflow checks that the release tag (v plus the package version) matches
package.json and server.json, runs the checks, and publishes to npm using
GitHub OIDC. It requires an npm trusted publisher configured for user
amidabuddha, repository jev-decision-mcp, workflow filename publish-npm.yml,
no environment name, and permission for direct npm publish. No npm token is needed.
For a new release, update package.json, package-lock.json, and all version
fields in server.json together, then publish a matching GitHub release from
that commit. Confirm the Publish npm workflow succeeds. Existing versions
cannot be published again; prereleases are not published by this workflow.
The official MCP Registry uses the separate, manually triggered Publish MCP
Registry workflow. Run it from main after the corresponding npm version is
available. GitHub release creation alone does not confirm either publication.
To verify the publishable artifact locally, run npm pack --dry-run. The package
contains the compiled server, license, README, example input, and registry metadata.
Local .env files, tests, and development dependencies are not bundled.
Clients can launch the published npm package with
npx -y jev-decision-mcp@0.1.2. For that installation method, provide
TYPESAFE_API_KEY in the MCP host's environment; the package does not read a .env
from the caller's working directory. The clone-and-build setup above remains
available independently of npm publication.
Glama's build configuration is managed in the listing's Dockerfile admin page.
Use build steps npm ci and npm run build, with CMD arguments
["node", "dist/index.js"]. No repository Dockerfile or TypeSafe key is needed
for inspection: the server starts without credentials and supports MCP
initialization and tools/list. Decision calls still require TYPESAFE_API_KEY.
Evaluate supplied context using TypeSafe Jev. Batch independent, narrow questions in one call: choice selects a provided label; score returns a position on 2–10 ordered levels (0-based); noul returns probability of yes, not intensity. Supply relevant evidence and full instructions; question IDs are not sent to the model. Include an other/none choice when appropriate. Questions cannot use each other's answers. Returns raw judgments, probabilities, confidence for choice/score, and token usage. Use caller-defined policies for uncertainty. This sends the supplied state and questions to TypeSafe and may incur API charges. It does not execute selected actions.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Optional TypeSafe model override; defaults to the configured model or jev-latest. | |
| state | Yes | Relevant source text or JSON context; include evidence, definitions and policies needed for the questions. | |
| questions | Yes | Named independent questions over the same state. IDs are not model instructions; write each full judgment in instructions. |
| Name | Required | Description |
|---|---|---|
| model | Yes | |
| usage | Yes | |
| answers | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even though annotations already declare readOnlyHint=true and destructiveHint=false, the description adds valuable behavioral context: question IDs are not sent to the model, the call sends supplied state to TypeSafe, may incur API charges, and does not execute selected actions. It also discloses what the returns contain (raw judgments, probabilities, confidence, token usage). No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence earns its place: type semantics, batching guidance, parameter intent, behavioral caveats, returns, and cost/non-execution notes are all present. It is front-loaded with the core purpose and then progressively adds usage and safety detail. There is no filler or tautology.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complex nested schema and the presence of an output schema, the description covers everything an agent needs: how to define each question type, what to put in state, which constraints apply (independence, other/none choice), what the call returns, and that it does not execute actions. The absence of sibling tools removes the need for differentiation, and return-value details are covered by the output schema. Nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is already strong, but the description adds meaning beyond the schema. It explains that state should contain evidence, definitions, and policies; that questions are named and independent; and that noul returns probability of yes rather than intensity. It also clarifies that 'score returns a position on 2–10 ordered levels (0-based)', which the schema alone does not convey. This materially helps an agent construct valid inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb-plus-resource ('Evaluate supplied context using TypeSafe Jev') and then enumerates the three decision types (choice, score, noul) with their distinct semantics. It clearly differentiates the tool's function from any generic decision helper, and the title aligns with the behavior. No ambiguity remains about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance: batch independent, narrow questions in one call, include evidence and full instructions, add an other/none choice when appropriate, and use caller-defined policies for uncertainty. It also states an exclusion—questions cannot use each other's answers—which tells an agent when not to combine or chain questions. This is actionable and specific.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0jev_decideScored across 1 tool
With only one tool, there is no possibility of confusion between tools. The tool's internal modes (choice, score, noul) are clearly delineated within the description, so an agent can unambiguously select this tool for any decision-related task.
The single tool name 'jev_decide' follows a clear prefix-verb pattern (server name + action). Since there is only one tool, there is no inconsistency to evaluate; the naming is predictable and matches the server's purpose.
One tool is slightly thin by general guidelines, but this server is highly specialized for decision-making. The tool consolidates multiple decision types into a single callable interface, making a larger tool count unnecessary. The count is reasonable for the narrow scope.
The tool comprehensively covers the decision-making domain: choice selection, scoring on ordered levels, and probability of a yes outcome. It also provides confidence metrics, token usage, and handles batching of independent questions. There are no obvious missing operations for a decision-support tool, as it explicitly does not execute actions.
A paid remote MCP for OpenAI Codex context compressor, built to return verdicts, receipts, usage log
Pay-per-call AI evaluation MCP server. Score LLM outputs against benchmark rubrics via Workers AI.
A paid remote MCP for OpenAI Codex agent coordination MCP, built to return verdicts, receipts, usage
MCP server for progressive tool usage at any scale (see https://klavis.ai)