@openrouter/sdk 1.2.117 → 1.2.118

package/esm/lib/config.d.ts

@@ -50,8 +50,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.117";
+    readonly sdkVersion: "1.2.118";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.2.117 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.2.118 2.914.0 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

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

package/esm/models/additionaltoolsitem.d.ts

@@ -59,6 +59,10 @@ export type AdditionalToolsItemToolFunction = {
     } | null;
     strict?: boolean | null | undefined;
     type: AdditionalToolsItemTypeFunction;
+    /**
+     * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
+     */
+    async?: boolean | undefined;
     /**
      * Withhold this tool from the model until `openrouter:tool_search` finds it. Requires the tool search server tool; at least one tool must remain non-deferred.
      */
@@ -99,6 +103,7 @@ export type AdditionalToolsItemToolFunction$Outbound = {
     } | null;
     strict?: boolean | null | undefined;
     type: string;
+    async?: boolean | undefined;
     defer_loading?: boolean | undefined;
 };
 /** @internal */

package/esm/models/additionaltoolsitem.js

@@ -74,6 +74,7 @@ export const AdditionalToolsItemToolFunction$outboundSchema = z.object({
     parameters: z.nullable(z.record(z.string(), z.any())),
     strict: z.nullable(z.boolean()).optional(),
     type: AdditionalToolsItemTypeFunction$outboundSchema,
+    async: z.boolean().optional(),
     deferLoading: z.boolean().optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/customtool.d.ts

@@ -25,6 +25,10 @@ export type CustomToolTypeCustom = ClosedEnum<typeof CustomToolTypeCustom>;
  * Custom tool configuration
  */
 export type CustomTool = {
+    /**
+     * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
+     */
+    async?: boolean | undefined;
     description?: string | undefined;
     format?: FormatText | FormatGrammar | discriminatedUnionTypes.Unknown<"type"> | undefined;
     name: string;
@@ -72,6 +76,7 @@ export declare const CustomToolTypeCustom$outboundSchema: z.ZodEnum<typeof Custo
 export declare const CustomTool$inboundSchema: z.ZodType<CustomTool, unknown>;
 /** @internal */
 export type CustomTool$Outbound = {
+    async?: boolean | undefined;
     description?: string | undefined;
     format?: FormatText$Outbound | FormatGrammar$Outbound | undefined;
     name: string;

package/esm/models/customtool.js

@@ -77,6 +77,7 @@ export const CustomToolTypeCustom$outboundSchema = CustomToolTypeCustom$inboundS
 /** @internal */
 export const CustomTool$inboundSchema = z
     .object({
+    async: z.boolean().optional(),
     description: z.string().optional(),
     format: discriminatedUnion("type", {
         text: z.lazy(() => FormatText$inboundSchema),
@@ -87,6 +88,7 @@ export const CustomTool$inboundSchema = z
 });
 /** @internal */
 export const CustomTool$outboundSchema = z.object({
+    async: z.boolean().optional(),
     description: z.string().optional(),
     format: z.union([
         z.lazy(() => FormatText$outboundSchema),

package/esm/models/customtoolcallitem.d.ts

@@ -9,6 +9,10 @@ export type CustomToolCallItemType = ClosedEnum<typeof CustomToolCallItemType>;
  * A call to a custom (freeform-grammar) tool created by the model — distinct from `function_call`. Used for tools like Codex CLI's `apply_patch` whose payload is opaque text rather than JSON arguments.
  */
 export type CustomToolCallItem = {
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
     callId: string;
     id?: string | undefined;
     input: string;
@@ -24,6 +28,7 @@ export type CustomToolCallItem = {
 export declare const CustomToolCallItemType$outboundSchema: z.ZodEnum<typeof CustomToolCallItemType>;
 /** @internal */
 export type CustomToolCallItem$Outbound = {
+    async?: boolean | undefined;
     call_id: string;
     id?: string | undefined;
     input: string;

package/esm/models/customtoolcallitem.js

@@ -12,6 +12,7 @@ export const CustomToolCallItemType = {
 export const CustomToolCallItemType$outboundSchema = z.enum(CustomToolCallItemType);
 /** @internal */
 export const CustomToolCallItem$outboundSchema = z.object({
+    async: z.boolean().optional(),
     callId: z.string(),
     id: z.string().optional(),
     input: z.string(),

package/esm/models/functioncallitem.d.ts

@@ -16,6 +16,10 @@ export type FunctionCallItemType = ClosedEnum<typeof FunctionCallItemType>;
  */
 export type FunctionCallItem = {
     arguments: string;
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
     callId: string;
     id: string;
     name: string;
@@ -47,6 +51,7 @@ export declare const FunctionCallItemType$outboundSchema: z.ZodEnum<typeof Funct
 /** @internal */
 export type FunctionCallItem$Outbound = {
     arguments: string;
+    async?: boolean | undefined;
     call_id: string;
     id: string;
     name: string;

package/esm/models/functioncallitem.js

@@ -28,6 +28,7 @@ export const FunctionCallItemType$outboundSchema = z.enum(FunctionCallItemType);
 /** @internal */
 export const FunctionCallItem$outboundSchema = z.object({
     arguments: z.string(),
+    async: z.boolean().optional(),
     callId: z.string(),
     id: z.string(),
     name: z.string(),

package/esm/models/fusionplugin.d.ts

@@ -33,7 +33,7 @@ export type FusionPluginTool = {
 };
 export type FusionPlugin = {
     /**
-     * For a Fusion run started by the `openrouter/fusion` model slug or `openrouter:fusion` server tool, slugs of models to run in parallel as the "expert panel" the analyst analyzes. Each model receives the same user prompt with web_search + web_fetch enabled. Capped at 8 models to bound cost amplification. When omitted, defaults to the Quality preset from the /labs/fusion UI (~anthropic/claude-opus-latest, ~openai/gpt-latest, ~google/gemini-pro-latest).
+     * For a Fusion run started by the `openrouter/fusion` model slug or `openrouter:fusion` server tool, slugs of models to run in parallel as the "expert panel" the analyst analyzes. Each model receives the same user prompt with web_search + web_fetch enabled. Capped at 8 models to bound cost amplification. When omitted, defaults to the Quality preset from the /labs/fusion UI (~anthropic/claude-opus-latest, ~openai/gpt-sol-latest, ~google/gemini-pro-latest).
      */
     analysisModels?: Array<string> | undefined;
     /**

package/esm/models/namespacefunctiontool.d.ts

@@ -12,6 +12,10 @@ export type AllowedCaller = OpenEnum<typeof AllowedCaller>;
  */
 export type NamespaceFunctionTool = {
     allowedCallers?: Array<AllowedCaller> | null | undefined;
+    /**
+     * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
+     */
+    async?: boolean | undefined;
     deferLoading?: boolean | undefined;
     description?: string | null | undefined;
     name: string;
@@ -33,6 +37,7 @@ export declare const NamespaceFunctionTool$inboundSchema: z.ZodType<NamespaceFun
 /** @internal */
 export type NamespaceFunctionTool$Outbound = {
     allowed_callers?: Array<string> | null | undefined;
+    async?: boolean | undefined;
     defer_loading?: boolean | undefined;
     description?: string | null | undefined;
     name: string;

package/esm/models/namespacefunctiontool.js

@@ -17,6 +17,7 @@ export const AllowedCaller$outboundSchema = openEnums.outboundSchema(AllowedCall
 /** @internal */
 export const NamespaceFunctionTool$inboundSchema = z.object({
     allowed_callers: z.nullable(z.array(AllowedCaller$inboundSchema)).optional(),
+    async: z.boolean().optional(),
     defer_loading: z.boolean().optional(),
     description: z.nullable(z.string()).optional(),
     name: z.string(),
@@ -34,6 +35,7 @@ export const NamespaceFunctionTool$inboundSchema = z.object({
 /** @internal */
 export const NamespaceFunctionTool$outboundSchema = z.object({
     allowedCallers: z.nullable(z.array(AllowedCaller$outboundSchema)).optional(),
+    async: z.boolean().optional(),
     deferLoading: z.boolean().optional(),
     description: z.nullable(z.string()).optional(),
     name: z.string(),

package/esm/models/openairesponsecustomtoolcall.d.ts

@@ -7,6 +7,10 @@ export declare const OpenAIResponseCustomToolCallType: {
 };
 export type OpenAIResponseCustomToolCallType = ClosedEnum<typeof OpenAIResponseCustomToolCallType>;
 export type OpenAIResponseCustomToolCall = {
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
     callId: string;
     id?: string | undefined;
     input: string;

package/esm/models/openairesponsecustomtoolcall.js

@@ -12,6 +12,7 @@ export const OpenAIResponseCustomToolCallType = {
 export const OpenAIResponseCustomToolCallType$inboundSchema = z.enum(OpenAIResponseCustomToolCallType);
 /** @internal */
 export const OpenAIResponseCustomToolCall$inboundSchema = z.object({
+    async: z.boolean().optional(),
     call_id: z.string(),
     id: z.string().optional(),
     input: z.string(),

package/esm/models/openairesponsefunctiontoolcall.d.ts

@@ -15,6 +15,10 @@ export declare const OpenAIResponseFunctionToolCallType: {
 export type OpenAIResponseFunctionToolCallType = ClosedEnum<typeof OpenAIResponseFunctionToolCallType>;
 export type OpenAIResponseFunctionToolCall = {
     arguments: string;
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
     callId: string;
     id?: string | undefined;
     name: string;

package/esm/models/openairesponsefunctiontoolcall.js

@@ -21,6 +21,7 @@ export const OpenAIResponseFunctionToolCallType$inboundSchema = z.enum(OpenAIRes
 /** @internal */
 export const OpenAIResponseFunctionToolCall$inboundSchema = z.object({
     arguments: z.string(),
+    async: z.boolean().optional(),
     call_id: z.string(),
     id: z.string().optional(),
     name: z.string(),

package/esm/models/openresponsesresult.d.ts

@@ -46,6 +46,10 @@ export type OpenResponsesResultToolFunction = {
     } | null;
     strict?: boolean | null | undefined;
     type: "function";
+    /**
+     * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
+     */
+    async?: boolean | undefined;
     /**
      * Withhold this tool from the model until `openrouter:tool_search` finds it. Requires the tool search server tool; at least one tool must remain non-deferred.
      */

package/esm/models/openresponsesresult.js

@@ -46,6 +46,7 @@ export const OpenResponsesResultToolFunction$inboundSchema = z.object({
     parameters: z.nullable(z.record(z.string(), z.any())),
     strict: z.nullable(z.boolean()).optional(),
     type: z.literal("function"),
+    async: z.boolean().optional(),
     defer_loading: z.boolean().optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/outputcustomtoolcallitem.d.ts

@@ -16,6 +16,10 @@ export type OutputCustomToolCallItemType = ClosedEnum<typeof OutputCustomToolCal
  * A call to a custom (freeform-grammar) tool created by the model — distinct from `function_call`. Used for tools like Codex CLI's `apply_patch` whose payload is opaque text rather than JSON arguments.
  */
 export type OutputCustomToolCallItem = {
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
     callId: string;
     id?: string | undefined;
     input: string;
@@ -39,6 +43,7 @@ export declare const OutputCustomToolCallItemType$outboundSchema: z.ZodEnum<type
 export declare const OutputCustomToolCallItem$inboundSchema: z.ZodType<OutputCustomToolCallItem, unknown>;
 /** @internal */
 export type OutputCustomToolCallItem$Outbound = {
+    async?: boolean | undefined;
     call_id: string;
     id?: string | undefined;
     input: string;

package/esm/models/outputcustomtoolcallitem.js

@@ -24,6 +24,7 @@ export const OutputCustomToolCallItemType$inboundSchema = z.enum(OutputCustomToo
 export const OutputCustomToolCallItemType$outboundSchema = OutputCustomToolCallItemType$inboundSchema;
 /** @internal */
 export const OutputCustomToolCallItem$inboundSchema = z.object({
+    async: z.boolean().optional(),
     call_id: z.string(),
     id: z.string().optional(),
     input: z.string(),
@@ -38,6 +39,7 @@ export const OutputCustomToolCallItem$inboundSchema = z.object({
 });
 /** @internal */
 export const OutputCustomToolCallItem$outboundSchema = z.object({
+    async: z.boolean().optional(),
     callId: z.string(),
     id: z.string().optional(),
     input: z.string(),

package/esm/models/outputfunctioncallitem.d.ts

@@ -27,6 +27,10 @@ export type OutputFunctionCallItemSubagentItem = {
 };
 export type OutputFunctionCallItem = {
     arguments: string;
+    /**
+     * True when the model called a tool declared with `async: true` and may continue its turn before the output is returned. Return the result in a later request as a `function_call_output` with this `call_id`.
+     */
+    async?: boolean | undefined;
     callId: string;
     id?: string | undefined;
     name: string;
@@ -85,6 +89,7 @@ export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunct
 /** @internal */
 export type OutputFunctionCallItem$Outbound = {
     arguments: string;
+    async?: boolean | undefined;
     call_id: string;
     id?: string | undefined;
     name: string;

package/esm/models/outputfunctioncallitem.js

@@ -76,6 +76,7 @@ export function outputFunctionCallItemSubagentItemFromJSON(jsonString) {
 /** @internal */
 export const OutputFunctionCallItem$inboundSchema = z.object({
     arguments: z.string(),
+    async: z.boolean().optional(),
     call_id: z.string(),
     id: z.string().optional(),
     name: z.string(),
@@ -98,6 +99,7 @@ export const OutputFunctionCallItem$inboundSchema = z.object({
 /** @internal */
 export const OutputFunctionCallItem$outboundSchema = z.object({
     arguments: z.string(),
+    async: z.boolean().optional(),
     callId: z.string(),
     id: z.string().optional(),
     name: z.string(),

package/esm/models/responseserrorfield.d.ts

@@ -22,6 +22,7 @@ export declare const Code: {
     readonly FailedToDownloadImage: "failed_to_download_image";
     readonly ImageFileNotFound: "image_file_not_found";
     readonly BioPolicy: "bio_policy";
+    readonly CyberPolicy: "cyber_policy";
     readonly MisalignmentPolicyViolation: "misalignment_policy_violation";
     readonly DataResidencyMismatch: "data_residency_mismatch";
 };

package/esm/models/responseserrorfield.js

@@ -25,6 +25,7 @@ export const Code = {
     FailedToDownloadImage: "failed_to_download_image",
     ImageFileNotFound: "image_file_not_found",
     BioPolicy: "bio_policy",
+    CyberPolicy: "cyber_policy",
     MisalignmentPolicyViolation: "misalignment_policy_violation",
     DataResidencyMismatch: "data_residency_mismatch",
 };

package/esm/models/responsesrequest.d.ts

@@ -96,6 +96,10 @@ export type ResponsesRequestToolFunction = {
     } | null;
     strict?: boolean | null | undefined;
     type: "function";
+    /**
+     * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
+     */
+    async?: boolean | undefined;
     /**
      * Withhold this tool from the model until `openrouter:tool_search` finds it. Requires the tool search server tool; at least one tool must remain non-deferred.
      */
@@ -343,6 +347,7 @@ export type ResponsesRequestToolFunction$Outbound = {
     } | null;
     strict?: boolean | null | undefined;
     type: "function";
+    async?: boolean | undefined;
     defer_loading?: boolean | undefined;
 };
 /** @internal */

package/esm/models/responsesrequest.js

@@ -112,6 +112,7 @@ export const ResponsesRequestToolFunction$outboundSchema = z.object({
     parameters: z.nullable(z.record(z.string(), z.any())),
     strict: z.nullable(z.boolean()).optional(),
     type: z.literal("function"),
+    async: z.boolean().optional(),
     deferLoading: z.boolean().optional(),
 }).transform((v) => {
     return remap$(v, {

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.2.117",
+  "version": "1.2.118",
   "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",
     "compile": "tsc",
-    "postinstall": "node scripts/check-types.js || true",
-    "prepare": "npm run build",
-    "test:e2e": "vitest --run --project e2e",
-    "typecheck": "tsc --noEmit",
     "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e",
     "test:transit": "exit 0",
-    "test:watch": "vitest --watch --project unit",
-    "typecheck:transit": "exit 0"
+    "typecheck": "tsc --noEmit",
+    "typecheck:transit": "exit 0",
+    "postinstall": "node scripts/check-types.js || true",
+    "prepare": "npm run build"
   },
   "peerDependencies": {},
   "devDependencies": {