standard-tool 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrey Gubanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,215 @@
+# standard-tool
+[![npm](https://img.shields.io/npm/v/standard-tool)](https://www.npmjs.com/package/standard-tool) [![CI](https://github.com/finom/standard-tool/actions/workflows/ci.yml/badge.svg)](https://github.com/finom/standard-tool/actions/workflows/ci.yml)
+
+> A **standalone**, dependency-free convention for defining LLM tools — built on [Standard Schema](https://standardschema.dev) + [Standard JSON Schema](https://standardschema.dev/json-schema).
+
+`standard-tool` is one tiny function that gives an LLM tool a single, neutral shape: a `name`, a `description`, an `execute` function, and `inputSchema`/`outputSchema` that both **validate** their data (Standard Schema) and **emit JSON Schema** for the model (Standard JSON Schema). No framework, no runtime dependencies — copy-paste it or `npm i standard-tool`.
+
+It's intended as a **community-wide standard** — the same way [Standard Schema](https://standardschema.dev) became a shared validation interface across Zod, Valibot, and ArkType, and the way the [Vercel AI SDK](https://ai-sdk.dev) popularized a common tool definition. The idea is one neutral contract that any library, framework, or app can **produce or consume**, instead of every project reinventing its own incompatible tool object.
+
+```ts
+import { standardTool } from 'standard-tool';
+import { z } from 'zod';
+
+const getWeather = standardTool({
+  name: 'get_weather',
+  description: 'Current temperature for a city',
+  inputSchema: z.object({ city: z.string() }),
+  outputSchema: z.object({ tempC: z.number() }),
+  execute: async ({ city }) => ({ tempC: 21 }), // `city` is typed; the return is validated
+});
+
+await getWeather.execute({ city: 'Paris' }); // → { tempC: number } | { error: string }; validated in & out (errors → { error } by default)
+```
+
+## What it is
+
+- **Standalone & dependency-free.** A single, small function. The Standard Schema and Standard JSON Schema interfaces are vendored into the package, so installing it pulls in nothing else — and you can just copy the source into your project instead (see [below](#or-just-copy-paste-it)).
+- **A convention, not a framework.** It doesn't run your agent, call your model, or own your runtime. It defines only the shape — `{ name, description, inputSchema?, outputSchema?, execute }` — and the things every tool needs: validation, a JSON Schema, and a model-facing result.
+- **Validates input _and_ output.** `execute` accepts untrusted input (e.g. JSON arguments from a model), validates it via Standard Schema (when you provide a schema — both are optional), runs your logic, then validates the result. **By default** a validation failure or a thrown error doesn't propagate — it comes back as `{ error: string }`, so a model loop keeps running; pass a `formatOutput` to reshape that (or to re-throw).
+- **Emits JSON Schema for any model.** Because the schemas implement Standard JSON Schema, you get an OpenAI- or MCP-ready JSON Schema (any function-calling model) synchronously via `inputSchema['~standard'].jsonSchema.input(...)`.
+
+## Why
+
+Every LLM framework ships its own tool object — Vercel AI SDK, MCP, oRPC, Effect — each a different shape, none portable, most welded to the framework. But the hard part — schema interop — is **already** standardized: Standard Schema for validation and Standard JSON Schema for JSON Schema emission. `standard-tool` is the missing, neutral wrapper around them: small enough to become a shared convention rather than another framework lock-in.
+
+## Install
+
+```sh
+npm i standard-tool
+# bring any library that implements BOTH Standard Schema and Standard JSON Schema:
+npm i zod          # 4.2+   (or `arktype` 2.1.28+, or `valibot` + `@valibot/to-json-schema`)
+```
+
+## Or just copy-paste it
+
+No dependency at all. Paste this and import the spec types from the official, types-only [`@standard-schema/spec`](https://github.com/standard-schema/standard-schema) (`npm i -D @standard-schema/spec`):
+
+```ts
+import type { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
+
+type CombinedSchema<T> = StandardSchemaV1<T> & StandardJSONSchemaV1<T>;
+
+export interface StandardTool<Input, Output, FormattedOutput = Output | { error: string }> {
+  name: string;
+  description: string;
+  inputSchema?: CombinedSchema<Input>;
+  outputSchema?: CombinedSchema<Output>;
+  execute(input: Input): FormattedOutput | Promise<FormattedOutput>;
+}
+
+export function standardTool<Input, Output, FormattedOutput = Output | { error: string }>(def: {
+  name: string;
+  description: string;
+  inputSchema?: CombinedSchema<Input>;
+  outputSchema?: CombinedSchema<Output>;
+  execute: (input: Input) => Output | Promise<Output>;
+  formatOutput?: (result: Output | Error) => FormattedOutput | Promise<FormattedOutput>;
+}): StandardTool<Input, Output, FormattedOutput> {
+  const check = async <T>(where: 'input' | 'output', s: CombinedSchema<T>, v: unknown): Promise<T> => {
+    const r = await s['~standard'].validate(v);
+    // a validation failure is a plain Error carrying the Standard Schema issues — no dedicated type:
+    if (r.issues) throw Object.assign(new Error(`${where} validation failed`), { issues: r.issues });
+    return r.value;
+  };
+  const formatOutput =
+    def.formatOutput ??
+    ((result: Output | Error) => (result instanceof Error ? { error: result.message } : result) as unknown as FormattedOutput);
+  return {
+    name: def.name,
+    description: def.description,
+    inputSchema: def.inputSchema,
+    outputSchema: def.outputSchema,
+    async execute(input) {
+      let result: Output | Error;
+      try {
+        const validInput = def.inputSchema ? await check('input', def.inputSchema, input) : input;
+        const output = await def.execute(validInput);
+        result = def.outputSchema ? await check('output', def.outputSchema, output) : output;
+      } catch (e) {
+        result = e instanceof Error ? e : new Error(String(e));
+      }
+      return formatOutput(result);
+    },
+  };
+}
+```
+
+## API
+
+```ts
+import { standardTool, type StandardTool, type FormatOutputFn } from 'standard-tool';
+
+standardTool(def): StandardTool<Input, Output, FormattedOutput>;
+```
+
+`Input`/`Output` are your **data types** (what your `execute` accepts and returns); the optional schemas describe them. `FormattedOutput` is what the tool hands the model after formatting — `Output | { error: string }` by default.
+
+| field | type | purpose |
+| --- | --- | --- |
+| `name` | `string` | tool name sent to the model |
+| `description` | `string` | what the tool does |
+| `inputSchema?` | `CombinedSchema<Input>` | optional input schema — validates **and** emits JSON Schema |
+| `outputSchema?` | `CombinedSchema<Output>` | optional output schema — validates **and** emits JSON Schema |
+| `execute` (yours) | `(input: Input) => Output \| Promise<Output>` | your logic — receives validated input, returns the output |
+| `execute` (tool) | `(input: Input) => FormattedOutput \| Promise<FormattedOutput>` | validate in → run yours → validate out → format; errors become the output (no throw) **by default** |
+| `formatOutput?` | `(result: Output \| Error) => FormattedOutput` | optional; maps the result — or an `Error` carrying `issues` — to the model output. Default `result instanceof Error ? { error: result.message } : result` |
+
+`inputSchema`/`outputSchema` are optional; when present they must implement both Standard Schema and Standard JSON Schema (Zod 4.2+, ArkType 2.1.28+, or Valibot 1.2+ via `@valibot/to-json-schema`) — `Input`/`Output` are inferred from them (or from `execute` when a schema is omitted).
+
+`standardTool` is deliberately a **thin utility**: `name`, `description`, `inputSchema`, and `outputSchema` are returned **exactly as you passed them**. Only `execute` is wrapped — it validates input and output (when schemas are present), then routes the result, or any thrown error (a validation failure is a plain `Error` carrying `issues`), through `formatOutput`. `formatOutput` defaults to the `{ error }` envelope so bad data doesn't throw and a model loop keeps going; supply your own to reshape the output (its return type becomes the tool's `FormattedOutput`) or to throw and surface the error. Note `formatOutput` is a **creation-time argument, not a field** on the returned tool — the shape stays the minimal `{ name, description, inputSchema?, outputSchema?, execute }`. That's the whole job.
+
+## Usage
+
+```ts
+import { standardTool } from 'standard-tool';
+import { z } from 'zod';
+
+const getWeather = standardTool({
+  name: 'get_weather',
+  description: 'Current temperature for a city',
+  inputSchema: z.object({ city: z.string() }),
+  outputSchema: z.object({ tempC: z.number() }),
+  execute: async ({ city }) => ({ tempC: 21 }),
+});
+
+// validated end to end — by default, bad input or output comes back as { error: string } (override via formatOutput):
+const out = await getWeather.execute({ city: 'Paris' }); // { tempC: number } | { error: string }
+
+// JSON Schema for the model (Standard JSON Schema), synchronous (inputSchema is optional, hence `!`):
+const parameters = getWeather.inputSchema!['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
+```
+
+## With the OpenAI API
+
+Uses the [Responses API](https://developers.openai.com/api/docs/guides/function-calling). Because every tool is the same neutral shape, you keep them in one array: `.map` it into the request's `tools`, then dispatch each function call back to the matching tool by `name`. Adding a fourth tool is one more array entry — no special-casing, no per-tool wiring. And because `execute` returns `{ error }` instead of throwing **by default**, a malformed tool call comes back to the model to self-correct rather than crashing your loop (a custom `formatOutput` can opt back into throwing).
+
+```ts
+import OpenAI from 'openai';
+import { z } from 'zod';
+import { standardTool, type StandardTool } from 'standard-tool';
+
+const client = new OpenAI();
+
+const tools: StandardTool<unknown, unknown>[] = [
+  standardTool({
+    name: 'get_weather',
+    description: 'Get the current temperature for a city',
+    inputSchema: z.object({ city: z.string() }),
+    outputSchema: z.object({ tempC: z.number() }),
+    execute: async ({ city }) => ({ tempC: 21 }),
+  }),
+  standardTool({
+    name: 'get_time',
+    description: 'Get the current time in an IANA timezone',
+    inputSchema: z.object({ timezone: z.string() }),
+    outputSchema: z.object({ iso: z.string() }),
+    execute: async ({ timezone }) => ({ iso: new Date().toLocaleString('en-US', { timeZone: timezone }) }),
+  }),
+  standardTool({
+    name: 'convert_currency',
+    description: 'Convert an amount between two currencies',
+    inputSchema: z.object({ amount: z.number(), from: z.string(), to: z.string() }),
+    outputSchema: z.object({ amount: z.number() }),
+    execute: async ({ amount }) => ({ amount: Math.round(amount * 1.08 * 100) / 100 }),
+  }),
+];
+
+const input: OpenAI.Responses.ResponseInput = [{ role: 'user', content: 'What is the weather in Paris?' }];
+
+const res = await client.responses.create({
+  model: 'gpt-5',
+  input,
+  // ← the payoff: one shape, one mapping for every tool
+  tools: tools.map((tool): OpenAI.Responses.Tool => ({
+    type: 'function',
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema ? tool.inputSchema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }) : {},
+    strict: false,
+  })),
+});
+
+input.push(...res.output);
+
+for (const item of res.output) {
+  if (item.type !== 'function_call') continue;
+  const tool = tools.find((t) => t.name === item.name);
+  if (!tool) continue;
+  const result = await tool.execute(JSON.parse(item.arguments)); // validates args + result; bad args → { error } by default
+  input.push({ type: 'function_call_output', call_id: item.call_id, output: JSON.stringify(result) });
+}
+
+const final = await client.responses.create({ model: 'gpt-5', input });
+console.log(final.output_text);
+```
+
+## Links
+
+- **Standard Schema** — https://standardschema.dev
+- **Standard JSON Schema** — https://standardschema.dev/json-schema
+- **@standard-schema/spec** — https://github.com/standard-schema/standard-schema
+
+## License
+
+MIT © Andrey Gubanov

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import type { CombinedSchema } from './standard-schema.js';
+export type * from './standard-schema.js';
+/** The default formatted output: your `Output`, or an `{ error }` envelope when execution or validation failed. */
+export type DefaultFormattedOutput<Output> = Output | {
+    error: string;
+};
+/**
+ * Maps a raw tool result — your `Output`, or an `Error` (carrying `issues` when a Standard Schema
+ * validation failed) — to the formatted output. Return an envelope to keep a model loop running,
+ * or throw to surface the error.
+ */
+export type FormatOutputFn<Output, FormattedOutput> = (result: Output | Error) => FormattedOutput | Promise<FormattedOutput>;
+/**
+ * A standard, DRY LLM tool over its **data** types `Input`/`Output`: `name` + `description` +
+ * optional Standard-Schema/JSON-Schema `inputSchema`/`outputSchema` + `execute(input: Input)`.
+ * `FormattedOutput` is what `execute` returns to the model after formatting — by default
+ * {@link DefaultFormattedOutput}, i.e. the data or an `{ error }` envelope.
+ */
+export interface StandardTool<Input, Output, FormattedOutput = DefaultFormattedOutput<Output>> {
+    name: string;
+    description: string;
+    /** Optional Standard Schema + Standard JSON Schema describing the input data. */
+    inputSchema?: CombinedSchema<Input>;
+    /** Optional Standard Schema + Standard JSON Schema describing the output data. */
+    outputSchema?: CombinedSchema<Output>;
+    /**
+     * Validate input (when `inputSchema`) → run your logic → validate output (when `outputSchema`) →
+     * format. **By default it doesn't throw**: a validation failure or a thrown error becomes the
+     * formatted output (`{ error: string }`) — unless your `formatOutput` throws — so a model loop
+     * keeps running.
+     */
+    execute(input: Input): FormattedOutput | Promise<FormattedOutput>;
+}
+/**
+ * Create a standard tool. `inputSchema`/`outputSchema` are optional; when present they must implement
+ * both Standard Schema (validation) and Standard JSON Schema (JSON Schema emission) — e.g. Zod 4.2+,
+ * ArkType 2.1.28+, or Valibot 1.2+ via `@valibot/to-json-schema`.
+ *
+ * Your `execute` receives the (validated) input and returns the output. The returned tool's `execute`
+ * validates input, runs yours, validates the result, then formats it via `formatOutput` — which by
+ * default turns any error into `{ error: message }` instead of throwing, so a model loop keeps going.
+ * Pass your own `formatOutput` to reshape the output (its return type becomes the tool's `FormattedOutput`)
+ * or to throw and surface the error. Validation failures are plain `Error`s carrying an `issues` array.
+ */
+export declare function standardTool<Input, Output, FormattedOutput = DefaultFormattedOutput<Output>>(def: {
+    name: string;
+    description: string;
+    inputSchema?: CombinedSchema<Input>;
+    outputSchema?: CombinedSchema<Output>;
+    execute: (input: Input) => Output | Promise<Output>;
+    formatOutput?: FormatOutputFn<Output, FormattedOutput>;
+}): StandardTool<Input, Output, FormattedOutput>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,sBAAsB,CAAC;AAE7E,mBAAmB,sBAAsB,CAAC;AAE1C,mHAAmH;AACnH,MAAM,MAAM,sBAAsB,CAAC,MAAM,IAAI,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,EAAE,eAAe,IAAI,CACpD,MAAM,EAAE,MAAM,GAAG,KAAK,KACnB,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,GAAG,sBAAsB,CAAC,MAAM,CAAC;IAC3F,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,WAAW,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IACpC,kFAAkF;IAClF,YAAY,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACtC;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CACnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,GAAG,sBAAsB,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE;IACjG,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IACpC,YAAY,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACtC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,YAAY,CAAC,EAAE,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACxD,GAAG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,CAAC,CAqB/C"}

package/dist/index.js

@@ -0,0 +1,44 @@
+/**
+ * Create a standard tool. `inputSchema`/`outputSchema` are optional; when present they must implement
+ * both Standard Schema (validation) and Standard JSON Schema (JSON Schema emission) — e.g. Zod 4.2+,
+ * ArkType 2.1.28+, or Valibot 1.2+ via `@valibot/to-json-schema`.
+ *
+ * Your `execute` receives the (validated) input and returns the output. The returned tool's `execute`
+ * validates input, runs yours, validates the result, then formats it via `formatOutput` — which by
+ * default turns any error into `{ error: message }` instead of throwing, so a model loop keeps going.
+ * Pass your own `formatOutput` to reshape the output (its return type becomes the tool's `FormattedOutput`)
+ * or to throw and surface the error. Validation failures are plain `Error`s carrying an `issues` array.
+ */
+export function standardTool(def) {
+    const formatOutput = def.formatOutput ??
+        ((result) => (result instanceof Error ? { error: result.message } : result));
+    return {
+        name: def.name,
+        description: def.description,
+        inputSchema: def.inputSchema,
+        outputSchema: def.outputSchema,
+        async execute(input) {
+            let result;
+            try {
+                const validInput = def.inputSchema ? await validate('input', def.inputSchema, input) : input;
+                const output = await def.execute(validInput);
+                result = def.outputSchema ? await validate('output', def.outputSchema, output) : output;
+            }
+            catch (error) {
+                result = error instanceof Error ? error : new Error(String(error));
+            }
+            return formatOutput(result);
+        },
+    };
+}
+async function validate(target, schema, value) {
+    const result = await schema['~standard'].validate(value); // await covers sync + async
+    if (result.issues) {
+        // A plain Error carrying the Standard Schema issues — no dedicated error type needed.
+        throw Object.assign(new Error(`${target} validation failed: ${result.issues.map((i) => i.message).join('; ')}`), {
+            issues: result.issues,
+        });
+    }
+    return result.value;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAkE,GAO7F;IACC,MAAM,YAAY,GAChB,GAAG,CAAC,YAAY;QAChB,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,MAAM,CAA+B,CAAC,CAAC;IAC7G,OAAO;QACL,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,KAAK,CAAC,OAAO,CAAC,KAAK;YACjB,IAAI,MAAsB,CAAC;YAC3B,IAAI,CAAC;gBACH,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;gBAC7F,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;gBAC7C,MAAM,GAAG,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;YAC1F,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACrE,CAAC;YACD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;KACF,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,QAAQ,CACrB,MAA0B,EAC1B,MAAS,EACT,KAAc;IAEd,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,4BAA4B;IACtF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,sFAAsF;QACtF,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,MAAM,uBAAuB,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;YAC/G,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC;AACtB,CAAC"}

package/dist/standard-schema.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Vendored Standard Schema + Standard JSON Schema interfaces — inlined so this package has ZERO dependencies.
+ * Source: https://github.com/standard-schema/standard-schema (MIT) + https://standardschema.dev/json-schema
+ * Identical to the @standard-schema/spec types; vendored here for copy-paste + dependency-free installs.
+ */
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** Props of a schema that implements BOTH Standard Schema and Standard JSON Schema. */
+export interface CombinedProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
+}
+/**
+ * A schema that BOTH validates (Standard Schema) and emits JSON Schema (Standard JSON Schema).
+ * Natively implemented by Zod 4.2+, ArkType 2.1.28+, Valibot 1.2+ (via @valibot/to-json-schema), and Vovk.
+ */
+export interface CombinedSchema<Input = unknown, Output = Input> {
+    readonly '~standard': CombinedProps<Input, Output>;
+}
+export declare namespace CombinedSchema {
+    type Target = StandardJSONSchemaV1.Target;
+    type InferInput<T extends StandardSchemaV1> = StandardSchemaV1.InferInput<T>;
+    type InferOutput<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+    type SuccessResult<T> = StandardSchemaV1.SuccessResult<T>;
+}
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"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"}

package/dist/standard-schema.js

@@ -0,0 +1,12 @@
+/**
+ * Vendored Standard Schema + Standard JSON Schema interfaces — inlined so this package has ZERO dependencies.
+ * Source: https://github.com/standard-schema/standard-schema (MIT) + https://standardschema.dev/json-schema
+ * Identical to the @standard-schema/spec types; vendored here for copy-paste + dependency-free installs.
+ */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable @typescript-eslint/no-namespace */
+// #########################
+// ###   Standard Typed  ###
+// #########################
+export {};
+//# sourceMappingURL=standard-schema.js.map

package/dist/standard-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4DAA4D;AAC5D,oDAAoD;AACpD,4BAA4B;AAC5B,4BAA4B;AAC5B,4BAA4B"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "standard-tool",
+  "version": "0.0.1",
+  "description": "Standard DRY LLM Tool Interface — name/description/execute with input & output validated via Standard Schema and emitted as JSON Schema via Standard JSON Schema. Zero dependencies.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "typecheck": "tsc -p tsconfig.test.json",
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "test": "npm run build && npm run typecheck && npm run lint && node --test",
+    "patch": "npm test && npm version patch",
+    "postversion": "npm run build && npm publish"
+  },
+  "keywords": [
+    "standard-schema",
+    "standard-json-schema",
+    "json-schema",
+    "llm",
+    "tool",
+    "function-calling",
+    "openai",
+    "mcp",
+    "validation",
+    "zod",
+    "valibot",
+    "arktype"
+  ],
+  "author": "Andrey Gubanov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/finom/standard-tool.git"
+  },
+  "homepage": "https://github.com/finom/standard-tool#readme",
+  "bugs": {
+    "url": "https://github.com/finom/standard-tool/issues"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.16",
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.2"
+  }
+}