@openrouter/sdk 1.2.116 → 1.2.118

package/esm/funcs/workspacesDeleteBudget.js

@@ -30,16 +30,16 @@ async function $do(client, request, options) {
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        id: encodeSimple("id", payload.id, {
+        interval: encodeSimple("interval", payload.interval, {
             explode: false,
             charEncoding: "percent",
         }),
-        interval: encodeSimple("interval", payload.interval, {
+        workspace_ref: encodeSimple("workspace_ref", payload.workspace_ref, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/workspaces/{id}/budgets/{interval}")(pathParams);
+    const path = pathToFunc("/workspaces/{workspace_ref}/budgets/{interval}")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/funcs/workspacesGetBudget.js

@@ -30,16 +30,16 @@ async function $do(client, request, options) {
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        id: encodeSimple("id", payload.id, {
+        interval: encodeSimple("interval", payload.interval, {
             explode: false,
             charEncoding: "percent",
         }),
-        interval: encodeSimple("interval", payload.interval, {
+        workspace_ref: encodeSimple("workspace_ref", payload.workspace_ref, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/workspaces/{id}/budgets/{interval}")(pathParams);
+    const path = pathToFunc("/workspaces/{workspace_ref}/budgets/{interval}")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/funcs/workspacesListBudgets.js

@@ -30,12 +30,12 @@ async function $do(client, request, options) {
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        id: encodeSimple("id", payload.id, {
+        workspace_ref: encodeSimple("workspace_ref", payload.workspace_ref, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/workspaces/{id}/budgets")(pathParams);
+    const path = pathToFunc("/workspaces/{workspace_ref}/budgets")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/funcs/workspacesSetBudget.js

@@ -32,16 +32,16 @@ async function $do(client, request, options) {
         explode: true,
     });
     const pathParams = {
-        id: encodeSimple("id", payload.id, {
+        interval: encodeSimple("interval", payload.interval, {
             explode: false,
             charEncoding: "percent",
         }),
-        interval: encodeSimple("interval", payload.interval, {
+        workspace_ref: encodeSimple("workspace_ref", payload.workspace_ref, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/workspaces/{id}/budgets/{interval}")(pathParams);
+    const path = pathToFunc("/workspaces/{workspace_ref}/budgets/{interval}")(pathParams);
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
         Accept: "application/json",

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.116";
+    readonly sdkVersion: "1.2.118";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.2.116 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.116",
+    sdkVersion: "1.2.118",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.2.116 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/operations/deleteworkspacebudget.d.ts

@@ -44,7 +44,7 @@ export type DeleteWorkspaceBudgetRequest = {
     /**
      * The workspace ID (UUID) or slug
      */
-    id: string;
+    workspaceRef: string;
     /**
      * Budget reset interval. Use "lifetime" for a one-time budget that never resets.
      */
@@ -55,7 +55,7 @@ export type DeleteWorkspaceBudgetRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    id: string;
+    workspace_ref: string;
     interval: string;
 };
 /** @internal */

package/esm/models/operations/deleteworkspacebudget.js

@@ -10,11 +10,12 @@ export const DeleteWorkspaceBudgetRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    id: z.string(),
+    workspaceRef: z.string(),
     interval: models.WorkspaceBudgetInterval$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
+        workspaceRef: "workspace_ref",
     });
 });
 export function deleteWorkspaceBudgetRequestToJSON(deleteWorkspaceBudgetRequest) {

package/esm/models/operations/getworkspacebudget.d.ts

@@ -44,7 +44,7 @@ export type GetWorkspaceBudgetRequest = {
     /**
      * The workspace ID (UUID) or slug
      */
-    id: string;
+    workspaceRef: string;
     /**
      * Budget reset interval. Use "lifetime" for a one-time budget that never resets.
      */
@@ -55,7 +55,7 @@ export type GetWorkspaceBudgetRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    id: string;
+    workspace_ref: string;
     interval: string;
 };
 /** @internal */

package/esm/models/operations/getworkspacebudget.js

@@ -10,11 +10,12 @@ export const GetWorkspaceBudgetRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    id: z.string(),
+    workspaceRef: z.string(),
     interval: models.WorkspaceBudgetInterval$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
+        workspaceRef: "workspace_ref",
     });
 });
 export function getWorkspaceBudgetRequestToJSON(getWorkspaceBudgetRequest) {

package/esm/models/operations/listworkspacebudgets.d.ts

@@ -43,14 +43,14 @@ export type ListWorkspaceBudgetsRequest = {
     /**
      * The workspace ID (UUID) or slug
      */
-    id: string;
+    workspaceRef: string;
 };
 /** @internal */
 export type ListWorkspaceBudgetsRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    id: string;
+    workspace_ref: string;
 };
 /** @internal */
 export declare const ListWorkspaceBudgetsRequest$outboundSchema: z.ZodType<ListWorkspaceBudgetsRequest$Outbound, ListWorkspaceBudgetsRequest>;

package/esm/models/operations/listworkspacebudgets.js

@@ -9,10 +9,11 @@ export const ListWorkspaceBudgetsRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    id: z.string(),
+    workspaceRef: z.string(),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
+        workspaceRef: "workspace_ref",
     });
 });
 export function listWorkspaceBudgetsRequestToJSON(listWorkspaceBudgetsRequest) {

package/esm/models/operations/upsertworkspacebudget.d.ts

@@ -44,7 +44,7 @@ export type UpsertWorkspaceBudgetRequest = {
     /**
      * The workspace ID (UUID) or slug
      */
-    id: string;
+    workspaceRef: string;
     /**
      * Budget reset interval. Use "lifetime" for a one-time budget that never resets.
      */
@@ -56,7 +56,7 @@ export type UpsertWorkspaceBudgetRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    id: string;
+    workspace_ref: string;
     interval: string;
     UpsertWorkspaceBudgetRequest: models.UpsertWorkspaceBudgetRequest$Outbound;
 };

package/esm/models/operations/upsertworkspacebudget.js

@@ -10,12 +10,13 @@ export const UpsertWorkspaceBudgetRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    id: z.string(),
+    workspaceRef: z.string(),
     interval: models.WorkspaceBudgetInterval$outboundSchema,
     upsertWorkspaceBudgetRequest: models.UpsertWorkspaceBudgetRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
+        workspaceRef: "workspace_ref",
         upsertWorkspaceBudgetRequest: "UpsertWorkspaceBudgetRequest",
     });
 });

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/esm/sdk/workspaces.d.ts

@@ -41,55 +41,55 @@ export declare class Workspaces extends ClientSDK {
      */
     update(request: operations.UpdateWorkspaceRequest, options?: RequestOptions): Promise<models.UpdateWorkspaceResponse>;
     /**
-     * List workspace budgets
+     * List workspace members
      *
      * @remarks
-     * List all budgets configured for a workspace. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * List all members of a workspace. Returns paginated results. For the default workspace, returns all organization members (implicit membership). [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    listBudgets(request: operations.ListWorkspaceBudgetsRequest, options?: RequestOptions): Promise<models.ListWorkspaceBudgetsResponse>;
+    listMembers(request: operations.ListWorkspaceMembersRequest, options?: RequestOptions): Promise<PageIterator<operations.ListWorkspaceMembersResponse, {
+        offset: number;
+    }>>;
     /**
-     * Delete a workspace budget
+     * Bulk add members to a workspace
      *
      * @remarks
-     * Remove the budget for a given interval. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * Add multiple organization members to a workspace. Members are assigned the same role they hold in the organization. [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    deleteBudget(request: operations.DeleteWorkspaceBudgetRequest, options?: RequestOptions): Promise<models.DeleteWorkspaceBudgetResponse>;
+    bulkAddMembers(request: operations.BulkAddWorkspaceMembersRequest, options?: RequestOptions): Promise<models.BulkAddWorkspaceMembersResponse>;
     /**
-     * Get a workspace budget
+     * Bulk remove members from a workspace
      *
      * @remarks
-     * Retrieve the budget for a given interval. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * Remove multiple members from a workspace. Members with active API keys in the workspace cannot be removed. SCIM-managed members cannot be removed; changes must be made in your identity provider. [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    getBudget(request: operations.GetWorkspaceBudgetRequest, options?: RequestOptions): Promise<models.GetWorkspaceBudgetResponse>;
+    bulkRemoveMembers(request: operations.BulkRemoveWorkspaceMembersRequest, options?: RequestOptions): Promise<models.BulkRemoveWorkspaceMembersResponse>;
     /**
-     * Create or update a workspace budget
+     * List workspace budgets
      *
      * @remarks
-     * Create or update the budget for a given interval. Budget limits must strictly decrease as the interval narrows (lifetime > monthly > weekly > daily). The optional `include_byok_in_budgets` flag is a workspace-wide setting: when provided it applies to every budget interval for the workspace, not just the interval in this request. Note that a change made here is applied to budget enforcement immediately, but an already-open workspace settings page in the web dashboard may keep showing the previous value until it is reloaded. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * List all budgets configured for a workspace. [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    setBudget(request: operations.UpsertWorkspaceBudgetRequest, options?: RequestOptions): Promise<models.UpsertWorkspaceBudgetResponse>;
+    listBudgets(request: operations.ListWorkspaceBudgetsRequest, options?: RequestOptions): Promise<models.ListWorkspaceBudgetsResponse>;
     /**
-     * List workspace members
+     * Delete a workspace budget
      *
      * @remarks
-     * List all members of a workspace. Returns paginated results. For the default workspace, returns all organization members (implicit membership). [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * Remove the budget for a given interval. [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    listMembers(request: operations.ListWorkspaceMembersRequest, options?: RequestOptions): Promise<PageIterator<operations.ListWorkspaceMembersResponse, {
-        offset: number;
-    }>>;
+    deleteBudget(request: operations.DeleteWorkspaceBudgetRequest, options?: RequestOptions): Promise<models.DeleteWorkspaceBudgetResponse>;
     /**
-     * Bulk add members to a workspace
+     * Get a workspace budget
      *
      * @remarks
-     * Add multiple organization members to a workspace. Members are assigned the same role they hold in the organization. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * Retrieve the budget for a given interval. [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    bulkAddMembers(request: operations.BulkAddWorkspaceMembersRequest, options?: RequestOptions): Promise<models.BulkAddWorkspaceMembersResponse>;
+    getBudget(request: operations.GetWorkspaceBudgetRequest, options?: RequestOptions): Promise<models.GetWorkspaceBudgetResponse>;
     /**
-     * Bulk remove members from a workspace
+     * Create or update a workspace budget
      *
      * @remarks
-     * Remove multiple members from a workspace. Members with active API keys in the workspace cannot be removed. SCIM-managed members cannot be removed; changes must be made in your identity provider. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     * Create or update the budget for a given interval. Budget limits must strictly decrease as the interval narrows (lifetime > monthly > weekly > daily). The optional `include_byok_in_budgets` flag is a workspace-wide setting: when provided it applies to every budget interval for the workspace, not just the interval in this request. Note that a change made here is applied to budget enforcement immediately, but an already-open workspace settings page in the web dashboard may keep showing the previous value until it is reloaded. [Management key](/docs/guides/overview/auth/management-api-keys) required.
      */
-    bulkRemoveMembers(request: operations.BulkRemoveWorkspaceMembersRequest, options?: RequestOptions): Promise<models.BulkRemoveWorkspaceMembersResponse>;
+    setBudget(request: operations.UpsertWorkspaceBudgetRequest, options?: RequestOptions): Promise<models.UpsertWorkspaceBudgetResponse>;
 }
 //# sourceMappingURL=workspaces.d.ts.map

package/esm/sdk/workspaces.js

@@ -63,6 +63,33 @@ export class Workspaces extends ClientSDK {
     async update(request, options) {
         return unwrapAsync(workspacesUpdate(this, request, options));
     }
+    /**
+     * List workspace members
+     *
+     * @remarks
+     * List all members of a workspace. Returns paginated results. For the default workspace, returns all organization members (implicit membership). [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     */
+    async listMembers(request, options) {
+        return unwrapResultIterator(workspacesListMembers(this, request, options));
+    }
+    /**
+     * Bulk add members to a workspace
+     *
+     * @remarks
+     * Add multiple organization members to a workspace. Members are assigned the same role they hold in the organization. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     */
+    async bulkAddMembers(request, options) {
+        return unwrapAsync(workspacesBulkAddMembers(this, request, options));
+    }
+    /**
+     * Bulk remove members from a workspace
+     *
+     * @remarks
+     * Remove multiple members from a workspace. Members with active API keys in the workspace cannot be removed. SCIM-managed members cannot be removed; changes must be made in your identity provider. [Management key](/docs/guides/overview/auth/management-api-keys) required.
+     */
+    async bulkRemoveMembers(request, options) {
+        return unwrapAsync(workspacesBulkRemoveMembers(this, request, options));
+    }
     /**
      * List workspace budgets
      *
@@ -99,32 +126,5 @@ export class Workspaces extends ClientSDK {
     async setBudget(request, options) {
         return unwrapAsync(workspacesSetBudget(this, request, options));
     }
-    /**
-     * List workspace members
-     *
-     * @remarks
-     * List all members of a workspace. Returns paginated results. For the default workspace, returns all organization members (implicit membership). [Management key](/docs/guides/overview/auth/management-api-keys) required.
-     */
-    async listMembers(request, options) {
-        return unwrapResultIterator(workspacesListMembers(this, request, options));
-    }
-    /**
-     * Bulk add members to a workspace
-     *
-     * @remarks
-     * Add multiple organization members to a workspace. Members are assigned the same role they hold in the organization. [Management key](/docs/guides/overview/auth/management-api-keys) required.
-     */
-    async bulkAddMembers(request, options) {
-        return unwrapAsync(workspacesBulkAddMembers(this, request, options));
-    }
-    /**
-     * Bulk remove members from a workspace
-     *
-     * @remarks
-     * Remove multiple members from a workspace. Members with active API keys in the workspace cannot be removed. SCIM-managed members cannot be removed; changes must be made in your identity provider. [Management key](/docs/guides/overview/auth/management-api-keys) required.
-     */
-    async bulkRemoveMembers(request, options) {
-        return unwrapAsync(workspacesBulkRemoveMembers(this, request, options));
-    }
 }
 //# sourceMappingURL=workspaces.js.map

package/jsr.json

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