@openrouter/sdk 1.4.5 → 1.4.7

package/esm/models/servertoolengine.d.ts

@@ -0,0 +1,82 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ServerToolExecutedBy } from "./servertoolexecutedby.js";
+import { ServerToolPrice } from "./servertoolprice.js";
+/**
+ * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+ */
+export declare const BYOK: {
+    readonly Required: "required";
+    readonly Optional: "optional";
+    readonly None: "none";
+};
+/**
+ * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+ */
+export type BYOK = OpenEnum<typeof BYOK>;
+export declare const ServerToolEngineDataRegion: {
+    readonly Global: "global";
+    readonly Europe: "europe";
+    readonly Us: "us";
+};
+export type ServerToolEngineDataRegion = OpenEnum<typeof ServerToolEngineDataRegion>;
+/**
+ * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+ */
+export declare const PricingSource: {
+    readonly Openrouter: "openrouter";
+    readonly Provider: "provider";
+    readonly BYOK: "byok";
+    readonly None: "none";
+};
+/**
+ * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+ */
+export type PricingSource = OpenEnum<typeof PricingSource>;
+export type ServerToolEngine = {
+    /**
+     * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+     */
+    byok: BYOK;
+    /**
+     * The data regions whose requests this engine serves without leaving the region. A request pinned to a region can only use engines that list it; `global` is always listed.
+     */
+    dataRegions: Array<ServerToolEngineDataRegion>;
+    /**
+     * The `parameters.mode` a request without one runs and bills as; null for engines without modes. The `pricing[]` row with this `mode` is what an unmoded request bills
+     */
+    defaultMode: string | null;
+    /**
+     * Who runs the tool call: the model provider during inference (`provider`), OpenRouter (`openrouter`), or the caller's application after the call is returned (`client`).
+     */
+    executedBy: ServerToolExecutedBy;
+    /**
+     * The `parameters.engine` value that selects this engine; null for the single engine of a tool without an engine parameter
+     */
+    id: string | null;
+    name: string;
+    /**
+     * The rows OpenRouter bills; non-empty exactly when `pricing_source` is `openrouter`
+     */
+    pricing: Array<ServerToolPrice>;
+    /**
+     * Where the rates are documented when `pricing_source` is `provider` or `byok`; null otherwise
+     */
+    pricingDocUrl: string | null;
+    /**
+     * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+     */
+    pricingSource: PricingSource;
+};
+/** @internal */
+export declare const BYOK$inboundSchema: z.ZodType<BYOK, unknown>;
+/** @internal */
+export declare const ServerToolEngineDataRegion$inboundSchema: z.ZodType<ServerToolEngineDataRegion, unknown>;
+/** @internal */
+export declare const PricingSource$inboundSchema: z.ZodType<PricingSource, unknown>;
+/** @internal */
+export declare const ServerToolEngine$inboundSchema: z.ZodType<ServerToolEngine, unknown>;
+export declare function serverToolEngineFromJSON(jsonString: string): SafeParseResult<ServerToolEngine, SDKValidationError>;
+//# sourceMappingURL=servertoolengine.d.ts.map

package/esm/models/servertoolengine.js

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0ee547bdca50
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ServerToolExecutedBy$inboundSchema, } from "./servertoolexecutedby.js";
+import { ServerToolPrice$inboundSchema, } from "./servertoolprice.js";
+/**
+ * Whether the engine needs the caller's own key, saved in plugin settings: `required` (OpenRouter holds none), `optional` (OpenRouter's key is used unless the caller saved one), or `none`
+ */
+export const BYOK = {
+    Required: "required",
+    Optional: "optional",
+    None: "none",
+};
+export const ServerToolEngineDataRegion = {
+    Global: "global",
+    Europe: "europe",
+    Us: "us",
+};
+/**
+ * Who bills the engine's calls beyond the model's tokens: `openrouter` (the `pricing` rows, from the caller's credits), `provider` (a per-call tool fee from the model's provider on the inference call, at its own rates), `byok` (the engine's vendor, against the caller's own key), or `none` (no charge)
+ */
+export const PricingSource = {
+    Openrouter: "openrouter",
+    Provider: "provider",
+    BYOK: "byok",
+    None: "none",
+};
+/** @internal */
+export const BYOK$inboundSchema = openEnums
+    .inboundSchema(BYOK);
+/** @internal */
+export const ServerToolEngineDataRegion$inboundSchema = openEnums.inboundSchema(ServerToolEngineDataRegion);
+/** @internal */
+export const PricingSource$inboundSchema = openEnums.inboundSchema(PricingSource);
+/** @internal */
+export const ServerToolEngine$inboundSchema = z.object({
+    byok: BYOK$inboundSchema,
+    data_regions: z.array(ServerToolEngineDataRegion$inboundSchema),
+    default_mode: z.nullable(z.string()),
+    executed_by: ServerToolExecutedBy$inboundSchema,
+    id: z.nullable(z.string()),
+    name: z.string(),
+    pricing: z.array(ServerToolPrice$inboundSchema),
+    pricing_doc_url: z.nullable(z.string()),
+    pricing_source: PricingSource$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "data_regions": "dataRegions",
+        "default_mode": "defaultMode",
+        "executed_by": "executedBy",
+        "pricing_doc_url": "pricingDocUrl",
+        "pricing_source": "pricingSource",
+    });
+});
+export function serverToolEngineFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolEngine$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolEngine' from JSON`);
+}
+//# sourceMappingURL=servertoolengine.js.map

package/esm/models/servertoolexecutedby.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * Who runs the tool call: the model provider during inference (`provider`), OpenRouter (`openrouter`), or the caller's application after the call is returned (`client`).
+ */
+export declare const ServerToolExecutedBy: {
+    readonly Provider: "provider";
+    readonly Openrouter: "openrouter";
+    readonly Client: "client";
+};
+/**
+ * Who runs the tool call: the model provider during inference (`provider`), OpenRouter (`openrouter`), or the caller's application after the call is returned (`client`).
+ */
+export type ServerToolExecutedBy = OpenEnum<typeof ServerToolExecutedBy>;
+/** @internal */
+export declare const ServerToolExecutedBy$inboundSchema: z.ZodType<ServerToolExecutedBy, unknown>;
+//# sourceMappingURL=servertoolexecutedby.d.ts.map

package/esm/models/servertoolexecutedby.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cfa354bfe40d
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * Who runs the tool call: the model provider during inference (`provider`), OpenRouter (`openrouter`), or the caller's application after the call is returned (`client`).
+ */
+export const ServerToolExecutedBy = {
+    Provider: "provider",
+    Openrouter: "openrouter",
+    Client: "client",
+};
+/** @internal */
+export const ServerToolExecutedBy$inboundSchema = openEnums.inboundSchema(ServerToolExecutedBy);
+//# sourceMappingURL=servertoolexecutedby.js.map

package/esm/models/servertoolinputname.d.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ServerToolOutputName } from "./servertooloutputname.js";
+export declare const ServerToolInputNameApiFormat: {
+    readonly Responses: "responses";
+    readonly ChatCompletions: "chat-completions";
+    readonly AnthropicMessages: "anthropic-messages";
+};
+export type ServerToolInputNameApiFormat = OpenEnum<typeof ServerToolInputNameApiFormat>;
+export type ServerToolInputName = {
+    /**
+     * API formats that accept this spelling in `tools[].type`
+     */
+    apiFormats: Array<ServerToolInputNameApiFormat>;
+    /**
+     * What the call surfaces as on each accepting API format when requested under this spelling; a format is absent when the call is not visible to the caller
+     */
+    outputNames: Array<ServerToolOutputName>;
+    type: string;
+};
+/** @internal */
+export declare const ServerToolInputNameApiFormat$inboundSchema: z.ZodType<ServerToolInputNameApiFormat, unknown>;
+/** @internal */
+export declare const ServerToolInputName$inboundSchema: z.ZodType<ServerToolInputName, unknown>;
+export declare function serverToolInputNameFromJSON(jsonString: string): SafeParseResult<ServerToolInputName, SDKValidationError>;
+//# sourceMappingURL=servertoolinputname.d.ts.map

package/esm/models/servertoolinputname.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: deeca5c74395
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { ServerToolOutputName$inboundSchema, } from "./servertooloutputname.js";
+export const ServerToolInputNameApiFormat = {
+    Responses: "responses",
+    ChatCompletions: "chat-completions",
+    AnthropicMessages: "anthropic-messages",
+};
+/** @internal */
+export const ServerToolInputNameApiFormat$inboundSchema = openEnums.inboundSchema(ServerToolInputNameApiFormat);
+/** @internal */
+export const ServerToolInputName$inboundSchema = z.object({
+    api_formats: z.array(ServerToolInputNameApiFormat$inboundSchema),
+    output_names: z.array(ServerToolOutputName$inboundSchema),
+    type: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "api_formats": "apiFormats",
+        "output_names": "outputNames",
+    });
+});
+export function serverToolInputNameFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolInputName$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolInputName' from JSON`);
+}
+//# sourceMappingURL=servertoolinputname.js.map

package/esm/models/servertoolnativemodel.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ServerToolNativeModel = {
+    providers: Array<string>;
+    slug: string;
+};
+/** @internal */
+export declare const ServerToolNativeModel$inboundSchema: z.ZodType<ServerToolNativeModel, unknown>;
+export declare function serverToolNativeModelFromJSON(jsonString: string): SafeParseResult<ServerToolNativeModel, SDKValidationError>;
+//# sourceMappingURL=servertoolnativemodel.d.ts.map

package/esm/models/servertoolnativemodel.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 80f9cb866c58
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ServerToolNativeModel$inboundSchema = z.object({
+    providers: z.array(z.string()),
+    slug: z.string(),
+});
+export function serverToolNativeModelFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolNativeModel$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolNativeModel' from JSON`);
+}
+//# sourceMappingURL=servertoolnativemodel.js.map

package/esm/models/servertoolnativesupport.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Endpoints whose provider runs this tool itself during inference. Zero for tools no provider runs natively.
+ */
+export type ServerToolNativeSupport = {
+    endpointCount: number;
+    modelCount: number;
+};
+/** @internal */
+export declare const ServerToolNativeSupport$inboundSchema: z.ZodType<ServerToolNativeSupport, unknown>;
+export declare function serverToolNativeSupportFromJSON(jsonString: string): SafeParseResult<ServerToolNativeSupport, SDKValidationError>;
+//# sourceMappingURL=servertoolnativesupport.d.ts.map

package/esm/models/servertoolnativesupport.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3a84d88babcc
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ServerToolNativeSupport$inboundSchema = z.object({
+    endpoint_count: z.int(),
+    model_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "endpoint_count": "endpointCount",
+        "model_count": "modelCount",
+    });
+});
+export function serverToolNativeSupportFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolNativeSupport$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolNativeSupport' from JSON`);
+}
+//# sourceMappingURL=servertoolnativesupport.js.map

package/esm/models/servertooloutputname.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ServerToolOutputNameApiFormat: {
+    readonly Responses: "responses";
+    readonly ChatCompletions: "chat-completions";
+    readonly AnthropicMessages: "anthropic-messages";
+};
+export type ServerToolOutputNameApiFormat = OpenEnum<typeof ServerToolOutputNameApiFormat>;
+export type ServerToolOutputName = {
+    apiFormat: ServerToolOutputNameApiFormat;
+    /**
+     * Anthropic Messages `server_tool_use` block `name`, when the call surfaces as one
+     */
+    name?: string | undefined;
+    /**
+     * Output item `type` on Responses, content block `type` on Anthropic Messages, `reasoning_details[].type` on Chat Completions
+     */
+    type: string;
+};
+/** @internal */
+export declare const ServerToolOutputNameApiFormat$inboundSchema: z.ZodType<ServerToolOutputNameApiFormat, unknown>;
+/** @internal */
+export declare const ServerToolOutputName$inboundSchema: z.ZodType<ServerToolOutputName, unknown>;
+export declare function serverToolOutputNameFromJSON(jsonString: string): SafeParseResult<ServerToolOutputName, SDKValidationError>;
+//# sourceMappingURL=servertooloutputname.d.ts.map

package/esm/models/servertooloutputname.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1dd915c55b83
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const ServerToolOutputNameApiFormat = {
+    Responses: "responses",
+    ChatCompletions: "chat-completions",
+    AnthropicMessages: "anthropic-messages",
+};
+/** @internal */
+export const ServerToolOutputNameApiFormat$inboundSchema = openEnums.inboundSchema(ServerToolOutputNameApiFormat);
+/** @internal */
+export const ServerToolOutputName$inboundSchema = z.object({
+    api_format: ServerToolOutputNameApiFormat$inboundSchema,
+    name: z.string().optional(),
+    type: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "api_format": "apiFormat",
+    });
+});
+export function serverToolOutputNameFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolOutputName$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolOutputName' from JSON`);
+}
+//# sourceMappingURL=servertooloutputname.js.map

package/esm/models/servertoolprice.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ServerToolPrice = {
+    maxUnitsPerCall: number;
+    /**
+     * The `parameters.mode` this price applies to; null for prices that do not depend on the mode. A request bills exactly one `request` row
+     */
+    mode: string | null;
+    /**
+     * USD per unit, as a decimal string
+     */
+    price: string;
+    unit: string;
+};
+/** @internal */
+export declare const ServerToolPrice$inboundSchema: z.ZodType<ServerToolPrice, unknown>;
+export declare function serverToolPriceFromJSON(jsonString: string): SafeParseResult<ServerToolPrice, SDKValidationError>;
+//# sourceMappingURL=servertoolprice.d.ts.map

package/esm/models/servertoolprice.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d12fcc3fb6f8
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ServerToolPrice$inboundSchema = z.object({
+    max_units_per_call: z.int(),
+    mode: z.nullable(z.string()),
+    price: z.string(),
+    unit: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "max_units_per_call": "maxUnitsPerCall",
+    });
+});
+export function serverToolPriceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolPrice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolPrice' from JSON`);
+}
+//# sourceMappingURL=servertoolprice.js.map

package/esm/sdk/sdk.d.ts

@@ -30,6 +30,7 @@ import { Responses } from "./responses.js";
 import { Scim } from "./scim.js";
 import { STT } from "./stt.js";
 import { SystemOne } from "./systemone.js";
+import { Tools } from "./tools.js";
 import { TTS } from "./tts.js";
 import { Vault } from "./vault.js";
 import { VideoGeneration } from "./videogeneration.js";
@@ -105,6 +106,8 @@ export declare class OpenRouter extends ClientSDK {
     get scim(): Scim;
     private _systemOne?;
     get systemOne(): SystemOne;
+    private _tools?;
+    get tools(): Tools;
     private _vault?;
     get vault(): Vault;
     private _videoGeneration?;

package/esm/sdk/sdk.js

@@ -34,6 +34,7 @@ import { Responses } from "./responses.js";
 import { Scim } from "./scim.js";
 import { STT } from "./stt.js";
 import { SystemOne } from "./systemone.js";
+import { Tools } from "./tools.js";
 import { TTS } from "./tts.js";
 import { Vault } from "./vault.js";
 import { VideoGeneration } from "./videogeneration.js";
@@ -139,6 +140,9 @@ export class OpenRouter extends ClientSDK {
     get systemOne() {
         return (this._systemOne ?? (this._systemOne = new SystemOne(this._options)));
     }
+    get tools() {
+        return (this._tools ?? (this._tools = new Tools(this._options)));
+    }
     get vault() {
         return (this._vault ?? (this._vault = new Vault(this._options)));
     }

package/esm/sdk/tools.d.ts

@@ -0,0 +1,20 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+export declare class Tools extends ClientSDK {
+    /**
+     * List server tools
+     *
+     * @remarks
+     * Lists every server tool OpenRouter can run on behalf of a model: accepted `tools[].type` spellings per API format, the engines behind it with their pricing, and how many endpoints run it natively.
+     */
+    listTools(security: operations.ListToolsSecurity, request?: operations.ListToolsRequest | undefined, options?: RequestOptions): Promise<models.ListToolsResponse>;
+    /**
+     * Get a server tool
+     *
+     * @remarks
+     * One server tool by canonical name or any accepted alias, with the models that run it natively.
+     */
+    getTool(security: operations.GetToolSecurity, request: operations.GetToolRequest, options?: RequestOptions): Promise<operations.GetToolResponse | undefined>;
+}
+//# sourceMappingURL=tools.d.ts.map

package/esm/sdk/tools.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f997ccdd9dd9
+ */
+import { toolsGetTool } from "../funcs/toolsGetTool.js";
+import { toolsListTools } from "../funcs/toolsListTools.js";
+import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Tools extends ClientSDK {
+    /**
+     * List server tools
+     *
+     * @remarks
+     * Lists every server tool OpenRouter can run on behalf of a model: accepted `tools[].type` spellings per API format, the engines behind it with their pricing, and how many endpoints run it natively.
+     */
+    async listTools(security, request, options) {
+        return unwrapAsync(toolsListTools(this, security, request, options));
+    }
+    /**
+     * Get a server tool
+     *
+     * @remarks
+     * One server tool by canonical name or any accepted alias, with the models that run it natively.
+     */
+    async getTool(security, request, options) {
+        return unwrapAsync(toolsGetTool(this, security, request, options));
+    }
+}
+//# sourceMappingURL=tools.js.map

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 400+ language models through a unified API.",
   "keywords": [
@@ -21,8 +21,8 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.22.0",
   "publishConfig": {
-    "provenance": true,
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "type": "module",
   "main": "./esm/index.js",
@@ -73,15 +73,15 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc && node scripts/unbarrel-imports.js",
     "prepublishOnly": "npm run build",
-    "compile": "tsc && node scripts/unbarrel-imports.js",
     "postinstall": "node scripts/check-types.js || true",
     "prepare": "npm run build",
     "test": "vitest --run --project unit",
-    "test:transit": "exit 0",
-    "test:watch": "vitest --watch --project unit",
     "test:e2e": "vitest --run --project e2e",
+    "test:transit": "exit 0",
     "typecheck": "tsc --noEmit",
-    "typecheck:transit": "exit 0"
+    "typecheck:transit": "exit 0",
+    "compile": "tsc && node scripts/unbarrel-imports.js",
+    "test:watch": "vitest --watch --project unit"
   },
   "peerDependencies": {