@openrouter/sdk 1.2.36 → 1.2.38

package/esm/lib/config.d.ts

@@ -49,8 +49,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "1.2.36";
+    readonly sdkVersion: "1.2.38";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.2.36 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.2.38 2.914.0 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "1.2.36",
+    sdkVersion: "1.2.38",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.2.36 2.914.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 1.2.38 2.914.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/functioncallitem.d.ts

@@ -1,6 +1,12 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export type FunctionCallItemSubagentItem = {
+    type: string;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
 export declare const FunctionCallItemType: {
     readonly FunctionCall: "function_call";
 };
@@ -18,9 +24,25 @@ export type FunctionCallItem = {
      */
     namespace?: string | undefined;
     status?: ToolCallStatus | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. String id that matches the `call_id` of the `openrouter:subagent` server tool call that spawned the subagent. Present on every `function_call` item the subagent projects; absent on ordinary function calls.
+     */
+    subagentId?: string | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. The subagent's output items produced on this turn. Treat this as an opaque object; you must replay it in the request so that the subagent can continue execution of the tool with the same context. If a subagent created multiple parallel tool calls, only the first tool call will have this field. The other tool calls will only have `subagent_id`. Present only if the tool call originates from a subagent spawned by the `openrouter:subagent` server tool.
+     */
+    subagentItems?: Array<FunctionCallItemSubagentItem> | undefined;
     type: FunctionCallItemType;
 };
 /** @internal */
+export type FunctionCallItemSubagentItem$Outbound = {
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const FunctionCallItemSubagentItem$outboundSchema: z.ZodType<FunctionCallItemSubagentItem$Outbound, FunctionCallItemSubagentItem>;
+export declare function functionCallItemSubagentItemToJSON(functionCallItemSubagentItem: FunctionCallItemSubagentItem): string;
+/** @internal */
 export declare const FunctionCallItemType$outboundSchema: z.ZodEnum<typeof FunctionCallItemType>;
 /** @internal */
 export type FunctionCallItem$Outbound = {
@@ -30,6 +52,8 @@ export type FunctionCallItem$Outbound = {
     name: string;
     namespace?: string | undefined;
     status?: string | undefined;
+    subagent_id?: string | undefined;
+    subagent_items?: Array<FunctionCallItemSubagentItem$Outbound> | undefined;
     type: string;
 };
 /** @internal */

package/esm/models/functioncallitem.js

@@ -9,6 +9,21 @@ export const FunctionCallItemType = {
     FunctionCall: "function_call",
 };
 /** @internal */
+export const FunctionCallItemSubagentItem$outboundSchema = z.object({
+    type: z.string(),
+    additionalProperties: z.record(z.string(), z.any()).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function functionCallItemSubagentItemToJSON(functionCallItemSubagentItem) {
+    return JSON.stringify(FunctionCallItemSubagentItem$outboundSchema.parse(functionCallItemSubagentItem));
+}
+/** @internal */
 export const FunctionCallItemType$outboundSchema = z.enum(FunctionCallItemType);
 /** @internal */
 export const FunctionCallItem$outboundSchema = z.object({
@@ -18,10 +33,14 @@ export const FunctionCallItem$outboundSchema = z.object({
     name: z.string(),
     namespace: z.string().optional(),
     status: ToolCallStatus$outboundSchema.optional(),
+    subagentId: z.string().optional(),
+    subagentItems: z.array(z.lazy(() => FunctionCallItemSubagentItem$outboundSchema)).optional(),
     type: FunctionCallItemType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",
+        subagentId: "subagent_id",
+        subagentItems: "subagent_items",
     });
 });
 export function functionCallItemToJSON(functionCallItem) {

package/esm/models/openairesponsefunctiontoolcall.d.ts

@@ -3,6 +3,12 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
+export type OpenAIResponseFunctionToolCallSubagentItem = {
+    type: string;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
 export declare const OpenAIResponseFunctionToolCallType: {
     readonly FunctionCall: "function_call";
 };
@@ -17,9 +23,20 @@ export type OpenAIResponseFunctionToolCall = {
      */
     namespace?: string | undefined;
     status?: ToolCallStatus | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. String id that matches the `call_id` of the `openrouter:subagent` server tool call that spawned the subagent. Present on every `function_call` item the subagent projects; absent on ordinary function calls.
+     */
+    subagentId?: string | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. The subagent's output items produced on this turn. Treat this as an opaque object; you must replay it in the request so that the subagent can continue execution of the tool with the same context. If a subagent created multiple parallel tool calls, only the first tool call will have this field. The other tool calls will only have `subagent_id`. Present only if the tool call originates from a subagent spawned by the `openrouter:subagent` server tool.
+     */
+    subagentItems?: Array<OpenAIResponseFunctionToolCallSubagentItem> | undefined;
     type: OpenAIResponseFunctionToolCallType;
 };
 /** @internal */
+export declare const OpenAIResponseFunctionToolCallSubagentItem$inboundSchema: z.ZodType<OpenAIResponseFunctionToolCallSubagentItem, unknown>;
+export declare function openAIResponseFunctionToolCallSubagentItemFromJSON(jsonString: string): SafeParseResult<OpenAIResponseFunctionToolCallSubagentItem, SDKValidationError>;
+/** @internal */
 export declare const OpenAIResponseFunctionToolCallType$inboundSchema: z.ZodEnum<typeof OpenAIResponseFunctionToolCallType>;
 /** @internal */
 export declare const OpenAIResponseFunctionToolCall$inboundSchema: z.ZodType<OpenAIResponseFunctionToolCall, unknown>;

package/esm/models/openairesponsefunctiontoolcall.js

@@ -4,12 +4,19 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
-import { safeParse } from "../lib/schemas.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
 import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
 export const OpenAIResponseFunctionToolCallType = {
     FunctionCall: "function_call",
 };
 /** @internal */
+export const OpenAIResponseFunctionToolCallSubagentItem$inboundSchema = collectExtraKeys$(z.object({
+    type: z.string(),
+}).catchall(z.any()), "additionalProperties", true);
+export function openAIResponseFunctionToolCallSubagentItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenAIResponseFunctionToolCallSubagentItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponseFunctionToolCallSubagentItem' from JSON`);
+}
+/** @internal */
 export const OpenAIResponseFunctionToolCallType$inboundSchema = z.enum(OpenAIResponseFunctionToolCallType);
 /** @internal */
 export const OpenAIResponseFunctionToolCall$inboundSchema = z.object({
@@ -19,10 +26,14 @@ export const OpenAIResponseFunctionToolCall$inboundSchema = z.object({
     name: z.string(),
     namespace: z.string().optional(),
     status: ToolCallStatus$inboundSchema.optional(),
+    subagent_id: z.string().optional(),
+    subagent_items: z.array(z.lazy(() => OpenAIResponseFunctionToolCallSubagentItem$inboundSchema)).optional(),
     type: OpenAIResponseFunctionToolCallType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
+        "subagent_id": "subagentId",
+        "subagent_items": "subagentItems",
     });
 });
 export function openAIResponseFunctionToolCallFromJSON(jsonString) {

package/esm/models/outputfunctioncallitem.d.ts

@@ -19,6 +19,12 @@ export declare const OutputFunctionCallItemType: {
     readonly FunctionCall: "function_call";
 };
 export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
+export type OutputFunctionCallItemSubagentItem = {
+    type: string;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
 export type OutputFunctionCallItem = {
     arguments: string;
     callId: string;
@@ -30,6 +36,14 @@ export type OutputFunctionCallItem = {
     namespace?: string | undefined;
     status?: OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress | undefined;
     type: OutputFunctionCallItemType;
+    /**
+     * EXPERIMENTAL — subject to change without notice. String id that matches the `call_id` of the `openrouter:subagent` server tool call that spawned the subagent. Present on every `function_call` item the subagent projects; absent on ordinary function calls.
+     */
+    subagentId?: string | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. The subagent's output items produced on this turn. Treat this as an opaque object; you must replay it in the request so that the subagent can continue execution of the tool with the same context. If a subagent created multiple parallel tool calls, only the first tool call will have this field. The other tool calls will only have `subagent_id`. Present only if the tool call originates from a subagent spawned by the `openrouter:subagent` server tool.
+     */
+    subagentItems?: Array<OutputFunctionCallItemSubagentItem> | undefined;
 };
 /** @internal */
 export declare const OutputFunctionCallItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
@@ -56,6 +70,17 @@ export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof
 /** @internal */
 export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
 /** @internal */
+export declare const OutputFunctionCallItemSubagentItem$inboundSchema: z.ZodType<OutputFunctionCallItemSubagentItem, unknown>;
+/** @internal */
+export type OutputFunctionCallItemSubagentItem$Outbound = {
+    type: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const OutputFunctionCallItemSubagentItem$outboundSchema: z.ZodType<OutputFunctionCallItemSubagentItem$Outbound, OutputFunctionCallItemSubagentItem>;
+export declare function outputFunctionCallItemSubagentItemToJSON(outputFunctionCallItemSubagentItem: OutputFunctionCallItemSubagentItem): string;
+export declare function outputFunctionCallItemSubagentItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemSubagentItem, SDKValidationError>;
+/** @internal */
 export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunctionCallItem, unknown>;
 /** @internal */
 export type OutputFunctionCallItem$Outbound = {
@@ -66,6 +91,8 @@ export type OutputFunctionCallItem$Outbound = {
     namespace?: string | undefined;
     status?: string | string | string | undefined;
     type: string;
+    subagent_id?: string | undefined;
+    subagent_items?: Array<OutputFunctionCallItemSubagentItem$Outbound> | undefined;
 };
 /** @internal */
 export declare const OutputFunctionCallItem$outboundSchema: z.ZodType<OutputFunctionCallItem$Outbound, OutputFunctionCallItem>;

package/esm/models/outputfunctioncallitem.js

@@ -4,7 +4,7 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
-import { safeParse } from "../lib/schemas.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
 export const OutputFunctionCallItemStatusInProgress = {
     InProgress: "in_progress",
 };
@@ -52,6 +52,28 @@ export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCal
 /** @internal */
 export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
 /** @internal */
+export const OutputFunctionCallItemSubagentItem$inboundSchema = collectExtraKeys$(z.object({
+    type: z.string(),
+}).catchall(z.any()), "additionalProperties", true);
+/** @internal */
+export const OutputFunctionCallItemSubagentItem$outboundSchema = z.object({
+    type: z.string(),
+    additionalProperties: z.record(z.string(), z.any()).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function outputFunctionCallItemSubagentItemToJSON(outputFunctionCallItemSubagentItem) {
+    return JSON.stringify(OutputFunctionCallItemSubagentItem$outboundSchema.parse(outputFunctionCallItemSubagentItem));
+}
+export function outputFunctionCallItemSubagentItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFunctionCallItemSubagentItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemSubagentItem' from JSON`);
+}
+/** @internal */
 export const OutputFunctionCallItem$inboundSchema = z.object({
     arguments: z.string(),
     call_id: z.string(),
@@ -64,9 +86,13 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
         OutputFunctionCallItemStatusInProgress$inboundSchema,
     ]).optional(),
     type: OutputFunctionCallItemType$inboundSchema,
+    subagent_id: z.string().optional(),
+    subagent_items: z.array(z.lazy(() => OutputFunctionCallItemSubagentItem$inboundSchema)).optional(),
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
+        "subagent_id": "subagentId",
+        "subagent_items": "subagentItems",
     });
 });
 /** @internal */
@@ -82,9 +108,13 @@ export const OutputFunctionCallItem$outboundSchema = z.object({
         OutputFunctionCallItemStatusInProgress$outboundSchema,
     ]).optional(),
     type: OutputFunctionCallItemType$outboundSchema,
+    subagentId: z.string().optional(),
+    subagentItems: z.array(z.lazy(() => OutputFunctionCallItemSubagentItem$outboundSchema)).optional(),
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",
+        subagentId: "subagent_id",
+        subagentItems: "subagent_items",
     });
 });
 export function outputFunctionCallItemToJSON(outputFunctionCallItem) {

package/esm/models/outputfusionservertoolitem.d.ts

@@ -44,7 +44,7 @@ export type OutputFusionServerToolItem = {
      */
     failedModels?: Array<FailedModel> | undefined;
     /**
-     * Typed failure reason when the fusion run failed. Possible values include: all_panels_failed, insufficient_credits, rate_limited, invalid_model, judge_not_valid_json, judge_schema_mismatch, judge_upstream_error, judge_empty_completion. The four analysis-stage codes keep their pre-rename `judge_` spelling so existing consumers keep matching.
+     * Typed failure reason when the fusion run failed. Possible values include: all_panels_failed, insufficient_credits, rate_limited, invalid_model, judge_not_valid_json, judge_schema_mismatch, judge_upstream_error, judge_empty_completion. The four analysis-stage codes keep their pre-rename `judge_` spelling so existing consumers keep matching. The consumer-cancellation code is `cancelled`.
      */
     failureReason?: string | undefined;
     id?: string | undefined;

package/esm/models/outputsubagentservertoolitem.d.ts

@@ -11,6 +11,10 @@ export type OutputSubagentServerToolItemType = ClosedEnum<typeof OutputSubagentS
  * An openrouter:subagent server tool output item
  */
 export type OutputSubagentServerToolItem = {
+    /**
+     * EXPERIMENTAL — subject to change without notice. The `call_id` of the tool call that spawned this subagent. This id will also be included as the `subagent_id` on any `function_call` items created by the subagent. This must be returned in the request so the `function_call` can be matched with the correct subagent. A suspended `in_progress` item is announced once and never re-emitted or terminally closed — completion arrives as a new item with the same `call_id`.
+     */
+    callId?: string | undefined;
     /**
      * Error message when the subagent task did not produce an outcome.
      */
@@ -51,6 +55,7 @@ export declare const OutputSubagentServerToolItemType$outboundSchema: z.ZodEnum<
 export declare const OutputSubagentServerToolItem$inboundSchema: z.ZodType<OutputSubagentServerToolItem, unknown>;
 /** @internal */
 export type OutputSubagentServerToolItem$Outbound = {
+    call_id?: string | undefined;
     error?: string | undefined;
     id?: string | undefined;
     instance_name?: string | undefined;

package/esm/models/outputsubagentservertoolitem.js

@@ -15,6 +15,7 @@ export const OutputSubagentServerToolItemType$inboundSchema = z.enum(OutputSubag
 export const OutputSubagentServerToolItemType$outboundSchema = OutputSubagentServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputSubagentServerToolItem$inboundSchema = z.object({
+    call_id: z.string().optional(),
     error: z.string().optional(),
     id: z.string().optional(),
     instance_name: z.string().optional(),
@@ -27,6 +28,7 @@ export const OutputSubagentServerToolItem$inboundSchema = z.object({
     type: OutputSubagentServerToolItemType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
+        "call_id": "callId",
         "instance_name": "instanceName",
         "task_description": "taskDescription",
         "task_name": "taskName",
@@ -34,6 +36,7 @@ export const OutputSubagentServerToolItem$inboundSchema = z.object({
 });
 /** @internal */
 export const OutputSubagentServerToolItem$outboundSchema = z.object({
+    callId: z.string().optional(),
     error: z.string().optional(),
     id: z.string().optional(),
     instanceName: z.string().optional(),
@@ -46,6 +49,7 @@ export const OutputSubagentServerToolItem$outboundSchema = z.object({
     type: OutputSubagentServerToolItemType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
+        callId: "call_id",
         instanceName: "instance_name",
         taskDescription: "task_description",
         taskName: "task_name",

package/esm/models/subagentreasoning.d.ts

@@ -25,7 +25,7 @@ export type SubagentReasoning = {
      */
     effort?: SubagentReasoningEffort | undefined;
     /**
-     * Maximum number of reasoning tokens the subagent may use. Accepted and validated but not yet forwarded to the subagent call.
+     * Maximum number of reasoning tokens the subagent may use. Forwarded to the subagent call as `reasoning.max_tokens`.
      */
     maxTokens?: number | undefined;
 };

package/esm/models/subagentservertoolconfig.d.ts

@@ -5,6 +5,14 @@ import { SubagentReasoning, SubagentReasoning$Outbound } from "./subagentreasoni
  * Configuration for one openrouter:subagent server tool entry.
  */
 export type SubagentServerToolConfig = {
+    /**
+     * EXPERIMENTAL — subject to change without notice. When true, the subagent inherits every client function defined in the request's top-level `tools` list. Supported on the Responses API (`/api/v1/responses`) only; other APIs reject it with a `400`.
+     */
+    inheritFunctions?: boolean | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. Names of the top-level function tools that the subagent will inherit. Any tool that matches by name will be copied fully into the tools array of the subagent. When `inherit_functions` is `true`, this list does nothing, because every client function will be inherited by default. Names are trimmed before validation, so a whitespace-only name is rejected with a `400`. Supported on the Responses API (`/api/v1/responses`) only; other APIs reject it with a `400`.
+     */
+    inheritedFunctionNames?: Array<string> | undefined;
     /**
      * System instructions for the subagent. When omitted, the subagent responds with no system prompt of its own.
      */
@@ -14,7 +22,7 @@ export type SubagentServerToolConfig = {
      */
     maxCompletionTokens?: number | undefined;
     /**
-     * Maximum number of tool-calling steps the subagent may take during its agentic loop. Capped at 25. Only relevant when the subagent is given tools. Accepted and validated but not yet enforced on the subagent call.
+     * Maximum number of tool-calling steps the subagent may take during its agentic loop. Capped at 25. Only relevant when the subagent is given tools. Forwarded to the subagent call as `max_tool_calls`.
      */
     maxToolCalls?: number | undefined;
     /**
@@ -40,6 +48,8 @@ export type SubagentServerToolConfig = {
 };
 /** @internal */
 export type SubagentServerToolConfig$Outbound = {
+    inherit_functions?: boolean | undefined;
+    inherited_function_names?: Array<string> | undefined;
     instructions?: string | undefined;
     max_completion_tokens?: number | undefined;
     max_tool_calls?: number | undefined;

package/esm/models/subagentservertoolconfig.js

@@ -8,6 +8,8 @@ import { SubagentNestedTool$outboundSchema, } from "./subagentnestedtool.js";
 import { SubagentReasoning$outboundSchema, } from "./subagentreasoning.js";
 /** @internal */
 export const SubagentServerToolConfig$outboundSchema = z.object({
+    inheritFunctions: z.boolean().optional(),
+    inheritedFunctionNames: z.array(z.string()).optional(),
     instructions: z.string().optional(),
     maxCompletionTokens: z.int().optional(),
     maxToolCalls: z.int().optional(),
@@ -18,6 +20,8 @@ export const SubagentServerToolConfig$outboundSchema = z.object({
     tools: z.array(SubagentNestedTool$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
+        inheritFunctions: "inherit_functions",
+        inheritedFunctionNames: "inherited_function_names",
         maxCompletionTokens: "max_completion_tokens",
         maxToolCalls: "max_tool_calls",
     });

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.2.36",
+  "version": "1.2.38",
   "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": [
@@ -73,15 +73,15 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test:watch": "vitest --watch --project unit",
-    "typecheck": "tsc --noEmit",
-    "typecheck:transit": "exit 0",
     "compile": "tsc",
-    "postinstall": "node scripts/check-types.js || true",
     "prepare": "npm run build",
     "test": "vitest --run --project unit",
     "test:e2e": "vitest --run --project e2e",
-    "test:transit": "exit 0"
+    "test:transit": "exit 0",
+    "typecheck:transit": "exit 0",
+    "postinstall": "node scripts/check-types.js || true",
+    "test:watch": "vitest --watch --project unit",
+    "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {},
   "devDependencies": {