typescript-sdk VS typebox

For TypeScript you can refer to https://github.com/modelcontextprotocol/typescript-sdk/blob/...

There isn't much documentation available right now but you can ask coding agent eg. Claude Code to generate an example.

@modelcontextprotocol/sdk: MCP server framework

At the time of this writing, this is little more than a proof of concept as a combination of the starter Pulsar package-generator package, the Atom package creation tutorial and the example from the official MCP Typescript SDK with some editor tool functions registered. Hopefully it will become more soon, since I am looking forward to actually using it to build stuff!

MCP TypeScript SDK

For this, we're going to use McpServer from the modelcontextprotocol SDK. The SDK supports: Resources, Tools, Prompts. However for this demo we'll only need tools.

Building a custom MCP server is straightforward with the right tools. While servers can be written in any language supporting stdout, official SDKs simplify the process. The TypeScript SDK is a great starting point.

For me it was implementing a simple `execute_terminal_command` tool along with hooking up to my company's jira and gitlab (dont worry security gurus, for the command line, I have a hardcoded list of allowed read-only commands that the LLM can execute, and both jira and gitlab servers likewise have readonly options.

What I will say is I agree there should be an option to get rid of the chat confirmations of every single new tool call in a chat - as well as building a set of "profiles" of different tools depending what I'm working on. Also strongly agree there needs to be an internal prompt possibility to explicitely tell the LLM what tool(s) to favor and how to use them (even in addition to the descriptions / schemas of the tools themselves) I opened an issue on the anthropic repo exactly about this: https://github.com/modelcontextprotocol/typescript-sdk/issue...

MCP servers MCP servers act as bridges between your data sources and AI agents. They expose APIs, databases, or custom code as tools (or resources) that an MCP host can use. Servers can be built using their Python or TypeScript SDKs, making it flexible for developers to work with their preferred language.

I was using TypeBox but switched to Zod. I like TypeBox but I found I don't actually need my schema to be a JSON Schema and the one time I did want a JSON Schema it was hard to get actual JSON back out of TypeBox.

The thing I like about Zod is the "refinements" and "transforms" and the new "overwrite" in Zod 4 was just what I wanted.

TypeBox does have a transform (https://github.com/sinclairzx81/typebox?tab=readme-ov-file#t...) but you can't transform and then apply more validations and then maybe another transform, etc. For example, I like to trim strings before checking length.

My hunch was that Zod v4 started using eval (or, more precisely, JIT compilation via new Function) for validation. This isn’t a bad thing — libraries like TypeBox, ArkType, and even Sury use similar techniques for speed.

Sury uses new Function under the hood. This approach makes it the fastest schema library available, but also means it cannot be used in environments that don't allow dynamic code evaluation, like CloudFlare Workers. Most users won't be affected, but might be an issue for some. Regarding safety of the approach you shouldn't be worried. Everything embeded to the generated code is escaped and thoroughly tested. Also, other libraries like TypeBox and Zod@4 use new Function under the hood as well.

The original library only supports Zod. While Zod is excellent, many developers use alternatives like Valibot, ArkType, and TypeBox. hono-openapi is validator-agnostic, offering first-class support for multiple libraries.

If you were willing to bring additional zod tooling or move to something like TypeBox (https://github.com/sinclairzx81/typebox), the json schema would be a direct derivation of the tools' input schemas in code.

I'd recommend TypeBox[1] as an alternative, which has a runtime “compiler” for generating optimized JS functions from the type objects. It also produces a JSON schema, which can be useful for generating API docs and API clients if needed.

It also has a companion library[2] for generating TypeBox validators from TypeScript definitions, which I'm currently using in an RPC library I'm working on.

[1]: https://github.com/sinclairzx81/typebox

Big fan of your work and impressed by your productivity. Currently reading https://www.oreilly.com/library/view/unifying-business-data/....

Currently experimenting with programmatic generation of json schemas via https://github.com/sinclairzx81/typebox. Trying to maximize reuse of schema components.

Was wondering if JSON BinPack is a good serialization format to sign json documents? Can it be used to somehow canonicalize json?

The documentation can be found here.

So far I like the commonly used approach in the Typescript community best:

1. Create your Schema using https://zod.dev or https://github.com/sinclairzx81/typebox

2. Generate your Types from the schema. It's very simple to create partial or composite types, e.g. UpdateModel, InsertModels, Arrays of them, etc.

3. Most modern Frameworks have first class support for validation, like is a great example Fastify (with typebox). Just reuse your schema definition.

That is very easy, obvious and effective.