From b7409304f4ed37a03004683db63b079052f387bb Mon Sep 17 00:00:00 2001 From: "kernel-internal[bot]" <260533166+kernel-internal[bot]@users.noreply.github.com> Date: Mon, 26 Oct 2026 14:55:59 +0000 Subject: [PATCH 1/2] feat: Arm vault passkeys in browsers and sign WebAuthn requests in metro-api Stainless-Generated-From: ce1c14a7a377dd429ec177ca938d2905751a4303 --- api.md | 4 + src/kernel/resources/vaults/items.py | 356 +++++++++++ src/kernel/types/vaults/__init__.py | 10 + ...skey_vault_item_operation_request_param.py | 41 ++ .../vaults/credential_account_vault_item.py | 3 + .../credential_vault_field_definition.py | 2 +- ...tial_vault_field_definition_input_param.py | 2 +- .../credential_vault_field_input_param.py | 2 +- .../types/vaults/credential_vault_item.py | 3 + ...skey_vault_item_operation_request_param.py | 26 + .../vaults/item_perform_operation_params.py | 51 ++ .../managed_auth_credential_vault_field.py | 2 +- .../passkey_vault_item_operation_result.py | 22 + ...skey_vault_item_operation_request_param.py | 36 ++ src/kernel/types/vaults/vault_item.py | 6 + .../vaults/vault_item_operation_response.py | 8 + tests/api_resources/vaults/test_items.py | 556 ++++++++++++++++-- 17 files changed, 1070 insertions(+), 60 deletions(-) create mode 100644 src/kernel/types/vaults/arm_passkey_vault_item_operation_request_param.py create mode 100644 src/kernel/types/vaults/disarm_passkey_vault_item_operation_request_param.py create mode 100644 src/kernel/types/vaults/passkey_vault_item_operation_result.py create mode 100644 src/kernel/types/vaults/register_passkey_vault_item_operation_request_param.py diff --git a/api.md b/api.md index 67038a5c..ae4bb2bb 100644 --- a/api.md +++ b/api.md @@ -572,6 +572,7 @@ from kernel.types.vaults import ( AgentcardCheckoutAuthorization, AgentcardCheckoutPreparation, AgentcardPreparedProcessor, + ArmPasskeyVaultItemOperationRequest, AuthorizeVaultItemOperationRequest, CardVaultItemSpec, CardVaultItemState, @@ -593,6 +594,7 @@ from kernel.types.vaults import ( CredentialVaultItemSpecUpdate, CredentialVaultItemState, CredentialVaultItemUpdateRequest, + DisarmPasskeyVaultItemOperationRequest, FillVaultItemOperationRequest, FillVaultItemOperationResult, KernelCardState, @@ -618,7 +620,9 @@ from kernel.types.vaults import ( OnePasswordOAuthAction, OnePasswordRecoverVaultItemOperationRequest, OnePasswordRequestAccessVaultItemOperationRequest, + PasskeyVaultItemOperationResult, PrepareCheckoutVaultItemOperationRequest, + RegisterPasskeyVaultItemOperationRequest, RestartVerificationVaultItemOperationRequest, VaultCardAliases, VaultCardFillField, diff --git a/src/kernel/resources/vaults/items.py b/src/kernel/resources/vaults/items.py index 90484496..0347d455 100644 --- a/src/kernel/resources/vaults/items.py +++ b/src/kernel/resources/vaults/items.py @@ -759,6 +759,179 @@ def perform_operation( """ ... + @overload + def perform_operation( + self, + key: str, + *, + id_or_name: str, + browser_id: str, + type: Literal["arm_passkey"], + field: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> VaultItemOperationResponse: + """ + Retrieve the item first and invoke only an operation listed in + `available_operations`, following its natural-language description. Availability + is rechecked at execution time; unavailable operations return 409. Authorization + and preparation may call an external provider and return updated state. Link + cards advertise authorize; pass browser_id and page_url from the final checkout + page so Kernel can inspect the checkout. Eligible unused AgentCard cards + advertise prepare_checkout, which requires checkout context and obtains device + approval before native Square Pay. Keep the returned approval page open, poll + until ready_to_submit, then submit before preparation.expires_at. Unused + preparations expire automatically and cannot be reused. If spend-request + creation is rejected with a non-retryable provider error, the card item is + deleted and the provider's error code and message are returned. Rate limits + return HTTP 429 and retain the card item; stop, back off, and retry the same + authorize operation. + + Ready Kernel cards advertise fill. Fill delivers card details for a few minutes; + submit checkout promptly after filling. A repeated fill is safe. + + Fill returns a value-free execution result. Validation failures before writing + return 400 (invalid request or targets), 403 (access or destination denied), 404 + (resource not found), or 409 (item or browser not ready). Once writing starts, + known partial failures and indeterminate field outcomes return 200 with status + `failed` or `unknown`. Fill never submits the page, so it is safe to retry after + a failure, an `unknown` outcome, or a transport error. + + Args: + browser_id: Browser session ID, not a reusable browser name. + + field: Passkey field to arm. Required when more than one passkey field holds a passkey. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + ... + + @overload + def perform_operation( + self, + key: str, + *, + id_or_name: str, + browser_id: str, + type: Literal["register_passkey"], + field: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> VaultItemOperationResponse: + """ + Retrieve the item first and invoke only an operation listed in + `available_operations`, following its natural-language description. Availability + is rechecked at execution time; unavailable operations return 409. Authorization + and preparation may call an external provider and return updated state. Link + cards advertise authorize; pass browser_id and page_url from the final checkout + page so Kernel can inspect the checkout. Eligible unused AgentCard cards + advertise prepare_checkout, which requires checkout context and obtains device + approval before native Square Pay. Keep the returned approval page open, poll + until ready_to_submit, then submit before preparation.expires_at. Unused + preparations expire automatically and cannot be reused. If spend-request + creation is rejected with a non-retryable provider error, the card item is + deleted and the provider's error code and message are returned. Rate limits + return HTTP 429 and retain the card item; stop, back off, and retry the same + authorize operation. + + Ready Kernel cards advertise fill. Fill delivers card details for a few minutes; + submit checkout promptly after filling. A repeated fill is safe. + + Fill returns a value-free execution result. Validation failures before writing + return 400 (invalid request or targets), 403 (access or destination denied), 404 + (resource not found), or 409 (item or browser not ready). Once writing starts, + known partial failures and indeterminate field outcomes return 200 with status + `failed` or `unknown`. Fill never submits the page, so it is safe to retry after + a failure, an `unknown` outcome, or a transport error. + + Args: + browser_id: Browser session ID, not a reusable browser name. + + field: Empty passkey field to store the new passkey in. Required when more than one + passkey field is empty. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + ... + + @overload + def perform_operation( + self, + key: str, + *, + id_or_name: str, + browser_id: str, + type: Literal["disarm_passkey"], + field: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> VaultItemOperationResponse: + """ + Retrieve the item first and invoke only an operation listed in + `available_operations`, following its natural-language description. Availability + is rechecked at execution time; unavailable operations return 409. Authorization + and preparation may call an external provider and return updated state. Link + cards advertise authorize; pass browser_id and page_url from the final checkout + page so Kernel can inspect the checkout. Eligible unused AgentCard cards + advertise prepare_checkout, which requires checkout context and obtains device + approval before native Square Pay. Keep the returned approval page open, poll + until ready_to_submit, then submit before preparation.expires_at. Unused + preparations expire automatically and cannot be reused. If spend-request + creation is rejected with a non-retryable provider error, the card item is + deleted and the provider's error code and message are returned. Rate limits + return HTTP 429 and retain the card item; stop, back off, and retry the same + authorize operation. + + Ready Kernel cards advertise fill. Fill delivers card details for a few minutes; + submit checkout promptly after filling. A repeated fill is safe. + + Fill returns a value-free execution result. Validation failures before writing + return 400 (invalid request or targets), 403 (access or destination denied), 404 + (resource not found), or 409 (item or browser not ready). Once writing starts, + known partial failures and indeterminate field outcomes return 200 with status + `failed` or `unknown`. Fill never submits the page, so it is safe to retry after + a failure, an `unknown` outcome, or a transport error. + + Args: + browser_id: Browser session ID, not a reusable browser name. + + field: Limit disarming to one passkey field. Omit to disarm every passkey field of the + item. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + ... + @overload def perform_operation( self, @@ -1125,6 +1298,9 @@ def perform_operation( | Literal["collect"] | Literal["prepare_checkout"] | Literal["fill"] + | Literal["arm_passkey"] + | Literal["register_passkey"] + | Literal["disarm_passkey"] | Literal["1pw_create_access_request"] | Literal["1pw_access_request_status"] | Literal["1pw_fill"] @@ -1144,6 +1320,7 @@ def perform_operation( checkout: VaultCheckoutContextParam | Omit = omit, fields: Iterable[VaultFillFieldParam] | Omit = omit, timeout_ms: int | Omit = omit, + field: str | Omit = omit, goal: str | Omit = omit, keywords: SequenceNotStr[str] | Omit = omit, reason: str | Omit = omit, @@ -1183,6 +1360,7 @@ def perform_operation( "checkout": checkout, "fields": fields, "timeout_ms": timeout_ms, + "field": field, "goal": goal, "keywords": keywords, "reason": reason, @@ -2141,6 +2319,179 @@ async def perform_operation( """ ... + @overload + async def perform_operation( + self, + key: str, + *, + id_or_name: str, + browser_id: str, + type: Literal["arm_passkey"], + field: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> VaultItemOperationResponse: + """ + Retrieve the item first and invoke only an operation listed in + `available_operations`, following its natural-language description. Availability + is rechecked at execution time; unavailable operations return 409. Authorization + and preparation may call an external provider and return updated state. Link + cards advertise authorize; pass browser_id and page_url from the final checkout + page so Kernel can inspect the checkout. Eligible unused AgentCard cards + advertise prepare_checkout, which requires checkout context and obtains device + approval before native Square Pay. Keep the returned approval page open, poll + until ready_to_submit, then submit before preparation.expires_at. Unused + preparations expire automatically and cannot be reused. If spend-request + creation is rejected with a non-retryable provider error, the card item is + deleted and the provider's error code and message are returned. Rate limits + return HTTP 429 and retain the card item; stop, back off, and retry the same + authorize operation. + + Ready Kernel cards advertise fill. Fill delivers card details for a few minutes; + submit checkout promptly after filling. A repeated fill is safe. + + Fill returns a value-free execution result. Validation failures before writing + return 400 (invalid request or targets), 403 (access or destination denied), 404 + (resource not found), or 409 (item or browser not ready). Once writing starts, + known partial failures and indeterminate field outcomes return 200 with status + `failed` or `unknown`. Fill never submits the page, so it is safe to retry after + a failure, an `unknown` outcome, or a transport error. + + Args: + browser_id: Browser session ID, not a reusable browser name. + + field: Passkey field to arm. Required when more than one passkey field holds a passkey. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + ... + + @overload + async def perform_operation( + self, + key: str, + *, + id_or_name: str, + browser_id: str, + type: Literal["register_passkey"], + field: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> VaultItemOperationResponse: + """ + Retrieve the item first and invoke only an operation listed in + `available_operations`, following its natural-language description. Availability + is rechecked at execution time; unavailable operations return 409. Authorization + and preparation may call an external provider and return updated state. Link + cards advertise authorize; pass browser_id and page_url from the final checkout + page so Kernel can inspect the checkout. Eligible unused AgentCard cards + advertise prepare_checkout, which requires checkout context and obtains device + approval before native Square Pay. Keep the returned approval page open, poll + until ready_to_submit, then submit before preparation.expires_at. Unused + preparations expire automatically and cannot be reused. If spend-request + creation is rejected with a non-retryable provider error, the card item is + deleted and the provider's error code and message are returned. Rate limits + return HTTP 429 and retain the card item; stop, back off, and retry the same + authorize operation. + + Ready Kernel cards advertise fill. Fill delivers card details for a few minutes; + submit checkout promptly after filling. A repeated fill is safe. + + Fill returns a value-free execution result. Validation failures before writing + return 400 (invalid request or targets), 403 (access or destination denied), 404 + (resource not found), or 409 (item or browser not ready). Once writing starts, + known partial failures and indeterminate field outcomes return 200 with status + `failed` or `unknown`. Fill never submits the page, so it is safe to retry after + a failure, an `unknown` outcome, or a transport error. + + Args: + browser_id: Browser session ID, not a reusable browser name. + + field: Empty passkey field to store the new passkey in. Required when more than one + passkey field is empty. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + ... + + @overload + async def perform_operation( + self, + key: str, + *, + id_or_name: str, + browser_id: str, + type: Literal["disarm_passkey"], + field: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> VaultItemOperationResponse: + """ + Retrieve the item first and invoke only an operation listed in + `available_operations`, following its natural-language description. Availability + is rechecked at execution time; unavailable operations return 409. Authorization + and preparation may call an external provider and return updated state. Link + cards advertise authorize; pass browser_id and page_url from the final checkout + page so Kernel can inspect the checkout. Eligible unused AgentCard cards + advertise prepare_checkout, which requires checkout context and obtains device + approval before native Square Pay. Keep the returned approval page open, poll + until ready_to_submit, then submit before preparation.expires_at. Unused + preparations expire automatically and cannot be reused. If spend-request + creation is rejected with a non-retryable provider error, the card item is + deleted and the provider's error code and message are returned. Rate limits + return HTTP 429 and retain the card item; stop, back off, and retry the same + authorize operation. + + Ready Kernel cards advertise fill. Fill delivers card details for a few minutes; + submit checkout promptly after filling. A repeated fill is safe. + + Fill returns a value-free execution result. Validation failures before writing + return 400 (invalid request or targets), 403 (access or destination denied), 404 + (resource not found), or 409 (item or browser not ready). Once writing starts, + known partial failures and indeterminate field outcomes return 200 with status + `failed` or `unknown`. Fill never submits the page, so it is safe to retry after + a failure, an `unknown` outcome, or a transport error. + + Args: + browser_id: Browser session ID, not a reusable browser name. + + field: Limit disarming to one passkey field. Omit to disarm every passkey field of the + item. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + ... + @overload async def perform_operation( self, @@ -2507,6 +2858,9 @@ async def perform_operation( | Literal["collect"] | Literal["prepare_checkout"] | Literal["fill"] + | Literal["arm_passkey"] + | Literal["register_passkey"] + | Literal["disarm_passkey"] | Literal["1pw_create_access_request"] | Literal["1pw_access_request_status"] | Literal["1pw_fill"] @@ -2526,6 +2880,7 @@ async def perform_operation( checkout: VaultCheckoutContextParam | Omit = omit, fields: Iterable[VaultFillFieldParam] | Omit = omit, timeout_ms: int | Omit = omit, + field: str | Omit = omit, goal: str | Omit = omit, keywords: SequenceNotStr[str] | Omit = omit, reason: str | Omit = omit, @@ -2565,6 +2920,7 @@ async def perform_operation( "checkout": checkout, "fields": fields, "timeout_ms": timeout_ms, + "field": field, "goal": goal, "keywords": keywords, "reason": reason, diff --git a/src/kernel/types/vaults/__init__.py b/src/kernel/types/vaults/__init__.py index 1fc9c4fc..0b6acf2c 100644 --- a/src/kernel/types/vaults/__init__.py +++ b/src/kernel/types/vaults/__init__.py @@ -51,6 +51,7 @@ from .credential_vault_item_request_param import CredentialVaultItemRequestParam as CredentialVaultItemRequestParam from .kernel_wallet_vault_item_spec_param import KernelWalletVaultItemSpecParam as KernelWalletVaultItemSpecParam from .managed_auth_credential_vault_field import ManagedAuthCredentialVaultField as ManagedAuthCredentialVaultField +from .passkey_vault_item_operation_result import PasskeyVaultItemOperationResult as PasskeyVaultItemOperationResult from .one_password_credential_account_spec import OnePasswordCredentialAccountSpec as OnePasswordCredentialAccountSpec from .one_password_credential_account_state import ( OnePasswordCredentialAccountState as OnePasswordCredentialAccountState, @@ -103,9 +104,15 @@ from .one_password_fill_vault_item_operation_result import ( OnePasswordFillVaultItemOperationResult as OnePasswordFillVaultItemOperationResult, ) +from .arm_passkey_vault_item_operation_request_param import ( + ArmPasskeyVaultItemOperationRequestParam as ArmPasskeyVaultItemOperationRequestParam, +) from .webmcp_invoke_vault_item_operation_request_param import ( WebmcpInvokeVaultItemOperationRequestParam as WebmcpInvokeVaultItemOperationRequestParam, ) +from .disarm_passkey_vault_item_operation_request_param import ( + DisarmPasskeyVaultItemOperationRequestParam as DisarmPasskeyVaultItemOperationRequestParam, +) from .managed_auth_credential_vault_item_spec_input_param import ( ManagedAuthCredentialVaultItemSpecInputParam as ManagedAuthCredentialVaultItemSpecInputParam, ) @@ -115,6 +122,9 @@ from .prepare_checkout_vault_item_operation_request_param import ( PrepareCheckoutVaultItemOperationRequestParam as PrepareCheckoutVaultItemOperationRequestParam, ) +from .register_passkey_vault_item_operation_request_param import ( + RegisterPasskeyVaultItemOperationRequestParam as RegisterPasskeyVaultItemOperationRequestParam, +) from .one_password_fill_vault_item_operation_request_param import ( OnePasswordFillVaultItemOperationRequestParam as OnePasswordFillVaultItemOperationRequestParam, ) diff --git a/src/kernel/types/vaults/arm_passkey_vault_item_operation_request_param.py b/src/kernel/types/vaults/arm_passkey_vault_item_operation_request_param.py new file mode 100644 index 00000000..83429dca --- /dev/null +++ b/src/kernel/types/vaults/arm_passkey_vault_item_operation_request_param.py @@ -0,0 +1,41 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["ArmPasskeyVaultItemOperationRequestParam"] + + +class ArmPasskeyVaultItemOperationRequestParam(TypedDict, total=False): + """ + Let a browser attached to the item's vault sign in with a stored passkey. + Only invoke when the item advertises `arm_passkey`. Returns immediately; + there is no time limit. While armed, when a page in that browser whose + origin matches the passkey's relying party asks for a passkey + (`navigator.credentials.get`, including autofill requests made at page + load), Kernel answers with this passkey. The private key never enters the + browser: Kernel signs on its servers, using the origin Chrome reports for + the requesting frame. Arming a passkey for a relying party replaces any + passkey armed earlier in the browser for the same relying party. The arm + lasts until `disarm_passkey`, the browser ends, the vault is detached, or + the item or field is deleted. Drive the sign-in with your own browser + tools and inspect the page to confirm it. A page opened in a new tab + or window can run its first scripts before Kernel's handler attaches; + if such a page asks for a passkey as soon as it loads, reload it. While + armed, any script running on the relying party's pages can obtain a + sign-in without user interaction, as with a password manager that + fills automatically; disarm when the task is done. Passkeys report a + signature counter of 0 and backup flags, as synced passkeys do. + """ + + browser_id: Required[str] + """Browser session ID, not a reusable browser name.""" + + type: Required[Literal["arm_passkey"]] + + field: str + """Passkey field to arm. + + Required when more than one passkey field holds a passkey. + """ diff --git a/src/kernel/types/vaults/credential_account_vault_item.py b/src/kernel/types/vaults/credential_account_vault_item.py index 1440a280..b2f818f6 100644 --- a/src/kernel/types/vaults/credential_account_vault_item.py +++ b/src/kernel/types/vaults/credential_account_vault_item.py @@ -37,6 +37,9 @@ class AvailableOperation(BaseModel): "collect", "prepare_checkout", "fill", + "arm_passkey", + "register_passkey", + "disarm_passkey", "1pw_create_access_request", "1pw_access_request_status", "1pw_fill", diff --git a/src/kernel/types/vaults/credential_vault_field_definition.py b/src/kernel/types/vaults/credential_vault_field_definition.py index c8317687..5a0449e0 100644 --- a/src/kernel/types/vaults/credential_vault_field_definition.py +++ b/src/kernel/types/vaults/credential_vault_field_definition.py @@ -37,7 +37,7 @@ class CredentialVaultFieldDefinition(BaseModel): `credentialId`, `userHandle` (at most 64 bytes), and `key` (a PKCS#8 ECDSA P-256 private key), a lowercase `rpId` domain, and optional `username` and `userDisplayName`. Other CXF members are ignored. Passkeys are never filled into - pages. + pages; use arm_passkey to sign in with one and register_passkey to create one. """ label: Optional[str] = None diff --git a/src/kernel/types/vaults/credential_vault_field_definition_input_param.py b/src/kernel/types/vaults/credential_vault_field_definition_input_param.py index f97cf911..19fab7c5 100644 --- a/src/kernel/types/vaults/credential_vault_field_definition_input_param.py +++ b/src/kernel/types/vaults/credential_vault_field_definition_input_param.py @@ -32,7 +32,7 @@ class CredentialVaultFieldDefinitionInputParam(TypedDict, total=False): `credentialId`, `userHandle` (at most 64 bytes), and `key` (a PKCS#8 ECDSA P-256 private key), a lowercase `rpId` domain, and optional `username` and `userDisplayName`. Other CXF members are ignored. Passkeys are never filled into - pages. + pages; use arm_passkey to sign in with one and register_passkey to create one. """ label: str diff --git a/src/kernel/types/vaults/credential_vault_field_input_param.py b/src/kernel/types/vaults/credential_vault_field_input_param.py index 5e26bb8d..a72258df 100644 --- a/src/kernel/types/vaults/credential_vault_field_input_param.py +++ b/src/kernel/types/vaults/credential_vault_field_input_param.py @@ -27,7 +27,7 @@ class CredentialVaultFieldInputParam(TypedDict, total=False): `credentialId`, `userHandle` (at most 64 bytes), and `key` (a PKCS#8 ECDSA P-256 private key), a lowercase `rpId` domain, and optional `username` and `userDisplayName`. Other CXF members are ignored. Passkeys are never filled into - pages. + pages; use arm_passkey to sign in with one and register_passkey to create one. """ encrypted_value: str diff --git a/src/kernel/types/vaults/credential_vault_item.py b/src/kernel/types/vaults/credential_vault_item.py index 3749bd85..b7da27d3 100644 --- a/src/kernel/types/vaults/credential_vault_item.py +++ b/src/kernel/types/vaults/credential_vault_item.py @@ -44,6 +44,9 @@ class AvailableOperation(BaseModel): "collect", "prepare_checkout", "fill", + "arm_passkey", + "register_passkey", + "disarm_passkey", "1pw_create_access_request", "1pw_access_request_status", "1pw_fill", diff --git a/src/kernel/types/vaults/disarm_passkey_vault_item_operation_request_param.py b/src/kernel/types/vaults/disarm_passkey_vault_item_operation_request_param.py new file mode 100644 index 00000000..6e453aa2 --- /dev/null +++ b/src/kernel/types/vaults/disarm_passkey_vault_item_operation_request_param.py @@ -0,0 +1,26 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["DisarmPasskeyVaultItemOperationRequestParam"] + + +class DisarmPasskeyVaultItemOperationRequestParam(TypedDict, total=False): + """ + Stop a browser from using this item's passkeys: removes its armed + passkeys and its pending registration into this item. Pages that already + loaded keep Kernel's WebAuthn handler but get the browser's own behavior. + """ + + browser_id: Required[str] + """Browser session ID, not a reusable browser name.""" + + type: Required[Literal["disarm_passkey"]] + + field: str + """Limit disarming to one passkey field. + + Omit to disarm every passkey field of the item. + """ diff --git a/src/kernel/types/vaults/item_perform_operation_params.py b/src/kernel/types/vaults/item_perform_operation_params.py index 65b3ff7d..83729ceb 100644 --- a/src/kernel/types/vaults/item_perform_operation_params.py +++ b/src/kernel/types/vaults/item_perform_operation_params.py @@ -20,6 +20,9 @@ "CollectVaultItemOperationRequest", "PrepareCheckoutVaultItemOperationRequest", "FillVaultItemOperationRequest", + "ArmPasskeyVaultItemOperationRequest", + "RegisterPasskeyVaultItemOperationRequest", + "DisarmPasskeyVaultItemOperationRequest", "OnePasswordRequestAccessVaultItemOperationRequest", "OnePasswordPollAccessVaultItemOperationRequest", "OnePasswordFillVaultItemOperationRequest", @@ -128,6 +131,51 @@ class FillVaultItemOperationRequest(TypedDict, total=False): """ +class ArmPasskeyVaultItemOperationRequest(TypedDict, total=False): + id_or_name: Required[str] + + browser_id: Required[str] + """Browser session ID, not a reusable browser name.""" + + type: Required[Literal["arm_passkey"]] + + field: str + """Passkey field to arm. + + Required when more than one passkey field holds a passkey. + """ + + +class RegisterPasskeyVaultItemOperationRequest(TypedDict, total=False): + id_or_name: Required[str] + + browser_id: Required[str] + """Browser session ID, not a reusable browser name.""" + + type: Required[Literal["register_passkey"]] + + field: str + """Empty passkey field to store the new passkey in. + + Required when more than one passkey field is empty. + """ + + +class DisarmPasskeyVaultItemOperationRequest(TypedDict, total=False): + id_or_name: Required[str] + + browser_id: Required[str] + """Browser session ID, not a reusable browser name.""" + + type: Required[Literal["disarm_passkey"]] + + field: str + """Limit disarming to one passkey field. + + Omit to disarm every passkey field of the item. + """ + + class OnePasswordRequestAccessVaultItemOperationRequest(TypedDict, total=False): id_or_name: Required[str] @@ -228,6 +276,9 @@ class WebmcpInvokeVaultItemOperationRequest(TypedDict, total=False): CollectVaultItemOperationRequest, PrepareCheckoutVaultItemOperationRequest, FillVaultItemOperationRequest, + ArmPasskeyVaultItemOperationRequest, + RegisterPasskeyVaultItemOperationRequest, + DisarmPasskeyVaultItemOperationRequest, OnePasswordRequestAccessVaultItemOperationRequest, OnePasswordPollAccessVaultItemOperationRequest, OnePasswordFillVaultItemOperationRequest, diff --git a/src/kernel/types/vaults/managed_auth_credential_vault_field.py b/src/kernel/types/vaults/managed_auth_credential_vault_field.py index e13171c5..a5ad62ab 100644 --- a/src/kernel/types/vaults/managed_auth_credential_vault_field.py +++ b/src/kernel/types/vaults/managed_auth_credential_vault_field.py @@ -21,5 +21,5 @@ class ManagedAuthCredentialVaultField(BaseModel): `credentialId`, `userHandle` (at most 64 bytes), and `key` (a PKCS#8 ECDSA P-256 private key), a lowercase `rpId` domain, and optional `username` and `userDisplayName`. Other CXF members are ignored. Passkeys are never filled into - pages. + pages; use arm_passkey to sign in with one and register_passkey to create one. """ diff --git a/src/kernel/types/vaults/passkey_vault_item_operation_result.py b/src/kernel/types/vaults/passkey_vault_item_operation_result.py new file mode 100644 index 00000000..5e7e3293 --- /dev/null +++ b/src/kernel/types/vaults/passkey_vault_item_operation_result.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from typing_extensions import Literal + +from ..._models import BaseModel + +__all__ = ["PasskeyVaultItemOperationResult"] + + +class PasskeyVaultItemOperationResult(BaseModel): + status: Literal["armed", "disarmed"] + """ + armed means the browser will answer matching passkey requests; it does not mean + a page has asked yet. disarmed means the browser no longer uses this item's + passkeys. + """ + + type: Literal["arm_passkey", "register_passkey", "disarm_passkey"] + + rp_id: Optional[str] = None + """Relying party the armed passkey answers for. Returned by arm_passkey.""" diff --git a/src/kernel/types/vaults/register_passkey_vault_item_operation_request_param.py b/src/kernel/types/vaults/register_passkey_vault_item_operation_request_param.py new file mode 100644 index 00000000..7c609648 --- /dev/null +++ b/src/kernel/types/vaults/register_passkey_vault_item_operation_request_param.py @@ -0,0 +1,36 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, Required, TypedDict + +__all__ = ["RegisterPasskeyVaultItemOperationRequestParam"] + + +class RegisterPasskeyVaultItemOperationRequestParam(TypedDict, total=False): + """ + Let a browser attached to the item's vault create a passkey on a website + and store it in an empty passkey field. Only invoke when the item + advertises `register_passkey`; declare the field first, for example by + adding an optional passkey field with a credential update. Returns + immediately; there is no time limit. The next passkey a page in that + browser creates (`navigator.credentials.create`) is generated by Kernel, + stored in the field, and only then returned to the page, so the website + never receives a passkey Kernel failed to store. Each browser has one + pending registration; a later `register_passkey` replaces it. Drive the + website's "add a passkey" flow with your own browser tools, then confirm + by reading the item (the field reports `has_value`) or its + `credential_passkey_registered` event, and by signing in with + `arm_passkey`. Only ES256 passkeys are created. + """ + + browser_id: Required[str] + """Browser session ID, not a reusable browser name.""" + + type: Required[Literal["register_passkey"]] + + field: str + """Empty passkey field to store the new passkey in. + + Required when more than one passkey field is empty. + """ diff --git a/src/kernel/types/vaults/vault_item.py b/src/kernel/types/vaults/vault_item.py index 8064949b..165165fa 100644 --- a/src/kernel/types/vaults/vault_item.py +++ b/src/kernel/types/vaults/vault_item.py @@ -54,6 +54,9 @@ class WalletVaultItemAvailableOperation(BaseModel): "collect", "prepare_checkout", "fill", + "arm_passkey", + "register_passkey", + "disarm_passkey", "1pw_create_access_request", "1pw_access_request_status", "1pw_fill", @@ -156,6 +159,9 @@ class CardVaultItemAvailableOperation(BaseModel): "collect", "prepare_checkout", "fill", + "arm_passkey", + "register_passkey", + "disarm_passkey", "1pw_create_access_request", "1pw_access_request_status", "1pw_fill", diff --git a/src/kernel/types/vaults/vault_item_operation_response.py b/src/kernel/types/vaults/vault_item_operation_response.py index 03ec1cb7..dc8c4134 100644 --- a/src/kernel/types/vaults/vault_item_operation_response.py +++ b/src/kernel/types/vaults/vault_item_operation_response.py @@ -16,6 +16,7 @@ from .wallet_vault_item_state import WalletVaultItemState from .credential_account_vault_item import CredentialAccountVaultItem from .fill_vault_item_operation_result import FillVaultItemOperationResult +from .passkey_vault_item_operation_result import PasskeyVaultItemOperationResult from .webmcp_invoke_vault_item_operation_result import WebmcpInvokeVaultItemOperationResult from .one_password_fill_vault_item_operation_result import OnePasswordFillVaultItemOperationResult @@ -56,6 +57,9 @@ class WalletVaultItemAvailableOperation(BaseModel): "collect", "prepare_checkout", "fill", + "arm_passkey", + "register_passkey", + "disarm_passkey", "1pw_create_access_request", "1pw_access_request_status", "1pw_fill", @@ -158,6 +162,9 @@ class CardVaultItemAvailableOperation(BaseModel): "collect", "prepare_checkout", "fill", + "arm_passkey", + "register_passkey", + "disarm_passkey", "1pw_create_access_request", "1pw_access_request_status", "1pw_fill", @@ -210,6 +217,7 @@ class CardVaultItem(BaseModel): CredentialAccountVaultItem, CredentialVaultItem, FillVaultItemOperationResult, + PasskeyVaultItemOperationResult, OnePasswordFillVaultItemOperationResult, WebmcpInvokeVaultItemOperationResult, ] diff --git a/tests/api_resources/vaults/test_items.py b/tests/api_resources/vaults/test_items.py index 9f891314..92fa760e 100644 --- a/tests/api_resources/vaults/test_items.py +++ b/tests/api_resources/vaults/test_items.py @@ -960,13 +960,235 @@ def test_method_perform_operation_overload_7(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", - type="1pw_create_access_request", + browser_id="browser-session-id", + type="arm_passkey", ) assert_matches_type(VaultItemOperationResponse, item, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_perform_operation_with_all_params_overload_7(self, client: Kernel) -> None: + item = client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + field="passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_perform_operation_overload_7(self, client: Kernel) -> None: + response = client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_perform_operation_overload_7(self, client: Kernel) -> None: + with client.vaults.items.with_streaming_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_perform_operation_overload_7(self, client: Kernel) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): + client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="", + browser_id="browser-session-id", + type="arm_passkey", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"): + client.vaults.items.with_raw_response.perform_operation( + key="", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_perform_operation_overload_8(self, client: Kernel) -> None: + item = client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_perform_operation_with_all_params_overload_8(self, client: Kernel) -> None: + item = client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + field="passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_perform_operation_overload_8(self, client: Kernel) -> None: + response = client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_perform_operation_overload_8(self, client: Kernel) -> None: + with client.vaults.items.with_streaming_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_perform_operation_overload_8(self, client: Kernel) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): + client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="", + browser_id="browser-session-id", + type="register_passkey", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"): + client.vaults.items.with_raw_response.perform_operation( + key="", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_perform_operation_overload_9(self, client: Kernel) -> None: + item = client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_perform_operation_with_all_params_overload_9(self, client: Kernel) -> None: + item = client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + field="x", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_perform_operation_overload_9(self, client: Kernel) -> None: + response = client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_perform_operation_overload_9(self, client: Kernel) -> None: + with client.vaults.items.with_streaming_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_perform_operation_overload_9(self, client: Kernel) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): + client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="", + browser_id="browser-session-id", + type="disarm_passkey", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"): + client.vaults.items.with_raw_response.perform_operation( + key="", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_perform_operation_overload_10(self, client: Kernel) -> None: + item = client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + type="1pw_create_access_request", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_perform_operation_with_all_params_overload_10(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -979,7 +1201,7 @@ def test_method_perform_operation_with_all_params_overload_7(self, client: Kerne @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_raw_response_perform_operation_overload_7(self, client: Kernel) -> None: + def test_raw_response_perform_operation_overload_10(self, client: Kernel) -> None: response = client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -993,7 +1215,7 @@ def test_raw_response_perform_operation_overload_7(self, client: Kernel) -> None @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_streaming_response_perform_operation_overload_7(self, client: Kernel) -> None: + def test_streaming_response_perform_operation_overload_10(self, client: Kernel) -> None: with client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1009,7 +1231,7 @@ def test_streaming_response_perform_operation_overload_7(self, client: Kernel) - @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_path_params_perform_operation_overload_7(self, client: Kernel) -> None: + def test_path_params_perform_operation_overload_10(self, client: Kernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): client.vaults.items.with_raw_response.perform_operation( key="key", @@ -1026,7 +1248,7 @@ def test_path_params_perform_operation_overload_7(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_overload_8(self, client: Kernel) -> None: + def test_method_perform_operation_overload_11(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1036,7 +1258,7 @@ def test_method_perform_operation_overload_8(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_with_all_params_overload_8(self, client: Kernel) -> None: + def test_method_perform_operation_with_all_params_overload_11(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1047,7 +1269,7 @@ def test_method_perform_operation_with_all_params_overload_8(self, client: Kerne @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_raw_response_perform_operation_overload_8(self, client: Kernel) -> None: + def test_raw_response_perform_operation_overload_11(self, client: Kernel) -> None: response = client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1061,7 +1283,7 @@ def test_raw_response_perform_operation_overload_8(self, client: Kernel) -> None @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_streaming_response_perform_operation_overload_8(self, client: Kernel) -> None: + def test_streaming_response_perform_operation_overload_11(self, client: Kernel) -> None: with client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1077,7 +1299,7 @@ def test_streaming_response_perform_operation_overload_8(self, client: Kernel) - @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_path_params_perform_operation_overload_8(self, client: Kernel) -> None: + def test_path_params_perform_operation_overload_11(self, client: Kernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): client.vaults.items.with_raw_response.perform_operation( key="key", @@ -1094,7 +1316,7 @@ def test_path_params_perform_operation_overload_8(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_overload_9(self, client: Kernel) -> None: + def test_method_perform_operation_overload_12(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1106,7 +1328,7 @@ def test_method_perform_operation_overload_9(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_with_all_params_overload_9(self, client: Kernel) -> None: + def test_method_perform_operation_with_all_params_overload_12(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1120,7 +1342,7 @@ def test_method_perform_operation_with_all_params_overload_9(self, client: Kerne @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_raw_response_perform_operation_overload_9(self, client: Kernel) -> None: + def test_raw_response_perform_operation_overload_12(self, client: Kernel) -> None: response = client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1136,7 +1358,7 @@ def test_raw_response_perform_operation_overload_9(self, client: Kernel) -> None @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_streaming_response_perform_operation_overload_9(self, client: Kernel) -> None: + def test_streaming_response_perform_operation_overload_12(self, client: Kernel) -> None: with client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1154,7 +1376,7 @@ def test_streaming_response_perform_operation_overload_9(self, client: Kernel) - @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_path_params_perform_operation_overload_9(self, client: Kernel) -> None: + def test_path_params_perform_operation_overload_12(self, client: Kernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): client.vaults.items.with_raw_response.perform_operation( key="key", @@ -1175,7 +1397,7 @@ def test_path_params_perform_operation_overload_9(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_overload_10(self, client: Kernel) -> None: + def test_method_perform_operation_overload_13(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1185,7 +1407,7 @@ def test_method_perform_operation_overload_10(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_raw_response_perform_operation_overload_10(self, client: Kernel) -> None: + def test_raw_response_perform_operation_overload_13(self, client: Kernel) -> None: response = client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1199,7 +1421,7 @@ def test_raw_response_perform_operation_overload_10(self, client: Kernel) -> Non @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_streaming_response_perform_operation_overload_10(self, client: Kernel) -> None: + def test_streaming_response_perform_operation_overload_13(self, client: Kernel) -> None: with client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1215,7 +1437,7 @@ def test_streaming_response_perform_operation_overload_10(self, client: Kernel) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_path_params_perform_operation_overload_10(self, client: Kernel) -> None: + def test_path_params_perform_operation_overload_13(self, client: Kernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): client.vaults.items.with_raw_response.perform_operation( key="key", @@ -1232,7 +1454,7 @@ def test_path_params_perform_operation_overload_10(self, client: Kernel) -> None @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_overload_11(self, client: Kernel) -> None: + def test_method_perform_operation_overload_14(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1243,7 +1465,7 @@ def test_method_perform_operation_overload_11(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_with_all_params_overload_11(self, client: Kernel) -> None: + def test_method_perform_operation_with_all_params_overload_14(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1255,7 +1477,7 @@ def test_method_perform_operation_with_all_params_overload_11(self, client: Kern @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_raw_response_perform_operation_overload_11(self, client: Kernel) -> None: + def test_raw_response_perform_operation_overload_14(self, client: Kernel) -> None: response = client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1270,7 +1492,7 @@ def test_raw_response_perform_operation_overload_11(self, client: Kernel) -> Non @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_streaming_response_perform_operation_overload_11(self, client: Kernel) -> None: + def test_streaming_response_perform_operation_overload_14(self, client: Kernel) -> None: with client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1287,7 +1509,7 @@ def test_streaming_response_perform_operation_overload_11(self, client: Kernel) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_path_params_perform_operation_overload_11(self, client: Kernel) -> None: + def test_path_params_perform_operation_overload_14(self, client: Kernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): client.vaults.items.with_raw_response.perform_operation( key="key", @@ -1306,7 +1528,7 @@ def test_path_params_perform_operation_overload_11(self, client: Kernel) -> None @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_overload_12(self, client: Kernel) -> None: + def test_method_perform_operation_overload_15(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1333,7 +1555,7 @@ def test_method_perform_operation_overload_12(self, client: Kernel) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_method_perform_operation_with_all_params_overload_12(self, client: Kernel) -> None: + def test_method_perform_operation_with_all_params_overload_15(self, client: Kernel) -> None: item = client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -1363,7 +1585,7 @@ def test_method_perform_operation_with_all_params_overload_12(self, client: Kern @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_raw_response_perform_operation_overload_12(self, client: Kernel) -> None: + def test_raw_response_perform_operation_overload_15(self, client: Kernel) -> None: response = client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1394,7 +1616,7 @@ def test_raw_response_perform_operation_overload_12(self, client: Kernel) -> Non @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_streaming_response_perform_operation_overload_12(self, client: Kernel) -> None: + def test_streaming_response_perform_operation_overload_15(self, client: Kernel) -> None: with client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -1427,7 +1649,7 @@ def test_streaming_response_perform_operation_overload_12(self, client: Kernel) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - def test_path_params_perform_operation_overload_12(self, client: Kernel) -> None: + def test_path_params_perform_operation_overload_15(self, client: Kernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): client.vaults.items.with_raw_response.perform_operation( key="key", @@ -2905,13 +3127,235 @@ async def test_method_perform_operation_overload_7(self, async_client: AsyncKern item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", - type="1pw_create_access_request", + browser_id="browser-session-id", + type="arm_passkey", ) assert_matches_type(VaultItemOperationResponse, item, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_perform_operation_with_all_params_overload_7(self, async_client: AsyncKernel) -> None: + item = await async_client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + field="passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_perform_operation_overload_7(self, async_client: AsyncKernel) -> None: + response = await async_client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = await response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_perform_operation_overload_7(self, async_client: AsyncKernel) -> None: + async with async_client.vaults.items.with_streaming_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = await response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_perform_operation_overload_7(self, async_client: AsyncKernel) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): + await async_client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="", + browser_id="browser-session-id", + type="arm_passkey", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"): + await async_client.vaults.items.with_raw_response.perform_operation( + key="", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="arm_passkey", + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + item = await async_client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_perform_operation_with_all_params_overload_8(self, async_client: AsyncKernel) -> None: + item = await async_client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + field="passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + response = await async_client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = await response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + async with async_client.vaults.items.with_streaming_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = await response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): + await async_client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="", + browser_id="browser-session-id", + type="register_passkey", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"): + await async_client.vaults.items.with_raw_response.perform_operation( + key="", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="register_passkey", + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + item = await async_client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_perform_operation_with_all_params_overload_9(self, async_client: AsyncKernel) -> None: + item = await async_client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + field="x", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + response = await async_client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = await response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + async with async_client.vaults.items.with_streaming_response.perform_operation( + key="key", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = await response.parse() + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): + await async_client.vaults.items.with_raw_response.perform_operation( + key="key", + id_or_name="", + browser_id="browser-session-id", + type="disarm_passkey", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"): + await async_client.vaults.items.with_raw_response.perform_operation( + key="", + id_or_name="id_or_name", + browser_id="browser-session-id", + type="disarm_passkey", + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: + item = await async_client.vaults.items.perform_operation( + key="key", + id_or_name="id_or_name", + type="1pw_create_access_request", + ) + assert_matches_type(VaultItemOperationResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_perform_operation_with_all_params_overload_10(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -2924,7 +3368,7 @@ async def test_method_perform_operation_with_all_params_overload_7(self, async_c @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_raw_response_perform_operation_overload_7(self, async_client: AsyncKernel) -> None: + async def test_raw_response_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: response = await async_client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -2938,7 +3382,7 @@ async def test_raw_response_perform_operation_overload_7(self, async_client: Asy @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_streaming_response_perform_operation_overload_7(self, async_client: AsyncKernel) -> None: + async def test_streaming_response_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: async with async_client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -2954,7 +3398,7 @@ async def test_streaming_response_perform_operation_overload_7(self, async_clien @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_path_params_perform_operation_overload_7(self, async_client: AsyncKernel) -> None: + async def test_path_params_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): await async_client.vaults.items.with_raw_response.perform_operation( key="key", @@ -2971,7 +3415,7 @@ async def test_path_params_perform_operation_overload_7(self, async_client: Asyn @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -2981,7 +3425,7 @@ async def test_method_perform_operation_overload_8(self, async_client: AsyncKern @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_with_all_params_overload_8(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_with_all_params_overload_11(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -2992,7 +3436,7 @@ async def test_method_perform_operation_with_all_params_overload_8(self, async_c @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_raw_response_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + async def test_raw_response_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: response = await async_client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3006,7 +3450,7 @@ async def test_raw_response_perform_operation_overload_8(self, async_client: Asy @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_streaming_response_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + async def test_streaming_response_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: async with async_client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3022,7 +3466,7 @@ async def test_streaming_response_perform_operation_overload_8(self, async_clien @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_path_params_perform_operation_overload_8(self, async_client: AsyncKernel) -> None: + async def test_path_params_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): await async_client.vaults.items.with_raw_response.perform_operation( key="key", @@ -3039,7 +3483,7 @@ async def test_path_params_perform_operation_overload_8(self, async_client: Asyn @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3051,7 +3495,7 @@ async def test_method_perform_operation_overload_9(self, async_client: AsyncKern @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_with_all_params_overload_9(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_with_all_params_overload_12(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3065,7 +3509,7 @@ async def test_method_perform_operation_with_all_params_overload_9(self, async_c @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_raw_response_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + async def test_raw_response_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: response = await async_client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3081,7 +3525,7 @@ async def test_raw_response_perform_operation_overload_9(self, async_client: Asy @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_streaming_response_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + async def test_streaming_response_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: async with async_client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3099,7 +3543,7 @@ async def test_streaming_response_perform_operation_overload_9(self, async_clien @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_path_params_perform_operation_overload_9(self, async_client: AsyncKernel) -> None: + async def test_path_params_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): await async_client.vaults.items.with_raw_response.perform_operation( key="key", @@ -3120,7 +3564,7 @@ async def test_path_params_perform_operation_overload_9(self, async_client: Asyn @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_overload_13(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3130,7 +3574,7 @@ async def test_method_perform_operation_overload_10(self, async_client: AsyncKer @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_raw_response_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: + async def test_raw_response_perform_operation_overload_13(self, async_client: AsyncKernel) -> None: response = await async_client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3144,7 +3588,7 @@ async def test_raw_response_perform_operation_overload_10(self, async_client: As @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_streaming_response_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: + async def test_streaming_response_perform_operation_overload_13(self, async_client: AsyncKernel) -> None: async with async_client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3160,7 +3604,7 @@ async def test_streaming_response_perform_operation_overload_10(self, async_clie @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_path_params_perform_operation_overload_10(self, async_client: AsyncKernel) -> None: + async def test_path_params_perform_operation_overload_13(self, async_client: AsyncKernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): await async_client.vaults.items.with_raw_response.perform_operation( key="key", @@ -3177,7 +3621,7 @@ async def test_path_params_perform_operation_overload_10(self, async_client: Asy @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_overload_14(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3188,7 +3632,7 @@ async def test_method_perform_operation_overload_11(self, async_client: AsyncKer @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_with_all_params_overload_11(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_with_all_params_overload_14(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3200,7 +3644,7 @@ async def test_method_perform_operation_with_all_params_overload_11(self, async_ @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_raw_response_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: + async def test_raw_response_perform_operation_overload_14(self, async_client: AsyncKernel) -> None: response = await async_client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3215,7 +3659,7 @@ async def test_raw_response_perform_operation_overload_11(self, async_client: As @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_streaming_response_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: + async def test_streaming_response_perform_operation_overload_14(self, async_client: AsyncKernel) -> None: async with async_client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3232,7 +3676,7 @@ async def test_streaming_response_perform_operation_overload_11(self, async_clie @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_path_params_perform_operation_overload_11(self, async_client: AsyncKernel) -> None: + async def test_path_params_perform_operation_overload_14(self, async_client: AsyncKernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): await async_client.vaults.items.with_raw_response.perform_operation( key="key", @@ -3251,7 +3695,7 @@ async def test_path_params_perform_operation_overload_11(self, async_client: Asy @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_overload_15(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3278,7 +3722,7 @@ async def test_method_perform_operation_overload_12(self, async_client: AsyncKer @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_method_perform_operation_with_all_params_overload_12(self, async_client: AsyncKernel) -> None: + async def test_method_perform_operation_with_all_params_overload_15(self, async_client: AsyncKernel) -> None: item = await async_client.vaults.items.perform_operation( key="key", id_or_name="id_or_name", @@ -3308,7 +3752,7 @@ async def test_method_perform_operation_with_all_params_overload_12(self, async_ @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_raw_response_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: + async def test_raw_response_perform_operation_overload_15(self, async_client: AsyncKernel) -> None: response = await async_client.vaults.items.with_raw_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3339,7 +3783,7 @@ async def test_raw_response_perform_operation_overload_12(self, async_client: As @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_streaming_response_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: + async def test_streaming_response_perform_operation_overload_15(self, async_client: AsyncKernel) -> None: async with async_client.vaults.items.with_streaming_response.perform_operation( key="key", id_or_name="id_or_name", @@ -3372,7 +3816,7 @@ async def test_streaming_response_perform_operation_overload_12(self, async_clie @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize - async def test_path_params_perform_operation_overload_12(self, async_client: AsyncKernel) -> None: + async def test_path_params_perform_operation_overload_15(self, async_client: AsyncKernel) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id_or_name` but received ''"): await async_client.vaults.items.with_raw_response.perform_operation( key="key", From 4bf26fab30837b5a47c5448b7e12827944fc62f6 Mon Sep 17 00:00:00 2001 From: "kernel-internal[bot]" <260533166+kernel-internal[bot]@users.noreply.github.com> Date: Mon, 26 Oct 2026 15:01:30 +0000 Subject: [PATCH 2/2] release: 0.131.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 7 +++++++ pyproject.toml | 2 +- src/kernel/_version.py | 2 +- 4 files changed, 10 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 37e99723..a24ae611 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.130.0" + ".": "0.131.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index b886f450..037c5134 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # Changelog +## [0.131.0](https://github.com/kernel/kernel-python-sdk/compare/v0.130.0...v0.131.0) (2026-10-26) + + +### Features + +* Arm vault passkeys in browsers and sign WebAuthn requests in metro-api ([b740930](https://github.com/kernel/kernel-python-sdk/commit/b7409304f4ed37a03004683db63b079052f387bb)) + ## [0.130.0](https://github.com/kernel/kernel-python-sdk/compare/v0.129.0...v0.130.0) (2026-10-24) diff --git a/pyproject.toml b/pyproject.toml index afa56013..fa909a05 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "kernel" -version = "0.130.0" +version = "0.131.0" description = "The official Python library for the kernel API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/kernel/_version.py b/src/kernel/_version.py index bcb0d447..c129635d 100644 --- a/src/kernel/_version.py +++ b/src/kernel/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "kernel" -__version__ = "0.130.0" # x-release-please-version +__version__ = "0.131.0" # x-release-please-version