The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →If the function stays the same, why rewrite its tool wrapper for every LLM framework? A function exposed through an AI SDK and an MCP server may need separate declarations because each consumer expects its own fields, schemas, and result format. A proposed framework-independent TypeScript shape called StandardToolV0 aims to let developers define the tool once and adapt it where needed. It is a proposal, not an adopted standard.
Why similar tool objects are not interchangeable
A tool definition typically needs to identify the tool, describe it to a model, specify its input, and connect that declaration to executable code. Frameworks cover similar ground but place those pieces differently: an identifier might be a map key in one API and an object property in another; a schema may use a framework-specific field; and execution may be passed as a callback or registered separately.
As an Amazon Associate I earn from qualifying purchases.
Those differences mean a tool written for one framework does not automatically work in another. As Andrey Gubanov puts it, “The objects look alike, but they are not interchangeable, and each one needs its framework’s package.” A shared definition could reduce that coupling, but it cannot eliminate the need to translate at the boundaries.
Schema portability is a separate problem
Standard Schema for validation libraries
Standard Schema provides a shared TypeScript interface through which consumers can work with compatible validation libraries. It addresses how a library exposes validation behavior; it does not by itself ensure that every model API or framework accepts the same schema representation.
Standard JSON Schema for export
Standard JSON Schema adds a way to convert a schema into a JSON Schema dialect chosen by the consumer. The two specifications are independent: a tool can benefit from a common validation interface while still needing an export step for a provider that expects JSON Schema or another schema format.
Input and output schemas may also describe different types. For example, a validator could accept a string and transform it into a number. Treating the input and output schemas as necessarily identical would lose that distinction.
What StandardToolV0 proposes
StandardToolV0 is a proposed, framework-independent TypeScript object for a tool’s metadata, schemas, and execution function. Its described fields are:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
name: the tool’s identifier.title: an optional human-facing title.description: text describing the tool.inputSchemaandoutputSchema: optional schemas for the value accepted and the result produced.meta: optional static metadata.execute(input, context?): the function that runs the tool, with optional context.
The context parameter is not validated or represented in JSON Schema. The proposed interface is types-only; an optional reference wrapper, standardTool(), is described as validating inputs and outputs against their schemas. Another helper, withFormattedOutput(), is described as returning errors as data. These are features attributed to the article’s description of the proposal, not guarantees that every consumer will provide at runtime.
Rank #3
In particular, declaring an input schema does not, by itself, prove that arguments arriving from a model are checked. The wrapper or the tool implementation must perform that validation. An adapter that only translates a declaration is not a substitute for runtime checks.
Where framework definitions differ
Gubanov’s comparison was checked against the versions below in the September 30, 2026 article. It is a dated snapshot, not a statement of the latest versions available later.
| Framework or proposal | Where the tool identifier appears | Schema and execution distinction |
|---|---|---|
AI SDK (ai 7.0) |
Tool map key | Accepts Standard Schema directly; execution is managed by the SDK. |
Mastra (@mastra/core 1.72) |
id |
Uses its own tool definition and schema field. |
Genkit (genkit 1.42) |
name |
Uses its own tool definition and schema field. |
LangChain (@langchain/core 1.2) |
Framework-specific tool definition | Uses a schema field; schema compatibility differs from other consumers. |
MCP SDK (@modelcontextprotocol/sdk 1.31) |
Passed through registerTool arguments |
Registers a tool descriptor with an inputSchema. |
| StandardToolV0 | name |
Proposed shared shape with optional input and output schemas and an execute function. |
The point of the comparison is not that the frameworks do different jobs, but that their interfaces are not drop-in replacements. A reusable definition can keep a library’s core tool logic independent of a framework package; framework-specific adapters still need to map the name, schema, callback, and any other required properties.
Recommended Free Tools
What adapters must translate
A provider or protocol adapter has at least two jobs: present the tool in the consumer’s declaration format, then return execution results in the format that consumer expects. The mappings described in the article illustrate why sharing the definition does not remove integration work.
Best Value
| Consumer | Tool declaration or schema described | Result format described |
|---|---|---|
| OpenAI Responses API | JSON Schema draft 2020-12 | function_call_output |
| Anthropic | JSON Schema draft 2020-12 | tool_result |
| Gemini | OpenAPI 3.0 | functionResponse |
| MCP | inputSchema in the tool descriptor |
MCP content fields |
| AI SDK | Accepts Standard Schema directly | SDK-managed execution |
These mappings are those reported in the September 30, 2026 article; they should not be read as a promise that every API endpoint, model, or later release has identical requirements. An adapter must also account for differences in schema dialect and result shape rather than assuming that a valid declaration for one consumer will be valid for another.
When a shared definition helps—and what remains unresolved
A shared tool shape is most useful when the same library function needs to serve multiple frameworks or integrations. It can give the library one home for its name, description, schemas, metadata, and execution code, leaving adapters responsible for consumer-specific details. That separation may also reduce the need for a library to depend directly on each framework it supports.
StandardToolV0 remains a proposal with one maintainer, according to Gubanov’s article. That makes adoption and governance practical questions, not settled benefits: if frameworks and tool libraries do not produce or consume the shape, developers could end up maintaining another format alongside the existing ones. Its value depends on real interoperability, clear ownership, and adapters that preserve validation and output semantics.
Free tools Windows power users keep installed
One-click scans. No signup required.
Read Andrey Gubanov’s September 30, 2026 article on DEV Community.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
