From f5ca9046f4d7025af5e6fbdd9429e778f9b2567f Mon Sep 17 00:00:00 2001 From: saif <11242541+saifsmailbox98@users.noreply.github.com> Date: Tue, 17 Nov 2026 01:51:34 +0530 Subject: [PATCH 1/3] feat(agent-vault): session metadata on create, update and reads --- infisical_sdk/api_types.py | 4 +++ infisical_sdk/resources/agent_vault.py | 31 ++++++++++++++++----- tests/test_agent_vault.py | 37 +++++++++++++++++++++++++- 3 files changed, 65 insertions(+), 7 deletions(-) diff --git a/infisical_sdk/api_types.py b/infisical_sdk/api_types.py index c43d589..82a6fc6 100644 --- a/infisical_sdk/api_types.py +++ b/infisical_sdk/api_types.py @@ -599,6 +599,7 @@ class AgentVaultSession(BaseModel): accessBundle: Optional[AgentVaultSessionAccessBundle] = None onBehalfOf: Optional[AgentVaultSessionActor] = None services: Optional[List[AgentVaultInlineService]] = None + metadata: Dict[str, str] = field(default_factory=dict) @classmethod def from_dict(cls, data: Dict) -> 'AgentVaultSession': @@ -612,6 +613,7 @@ def from_dict(cls, data: Dict) -> 'AgentVaultSession': session_data['accessBundle'] = AgentVaultSessionAccessBundle.from_dict(data['accessBundle']) if data.get('services') is not None: session_data['services'] = [AgentVaultInlineService.from_dict(service) for service in data['services']] + session_data['metadata'] = data.get('metadata') or {} return super().from_dict(session_data) @@ -626,6 +628,7 @@ class CreatedAgentVaultSession(BaseModel): expiresAt: Optional[str] = None accessBundle: Optional[AgentVaultSessionAccessBundle] = None services: List[AgentVaultInlineService] = field(default_factory=list) + metadata: Dict[str, str] = field(default_factory=dict) @classmethod def from_dict(cls, data: Dict) -> 'CreatedAgentVaultSession': @@ -636,6 +639,7 @@ def from_dict(cls, data: Dict) -> 'CreatedAgentVaultSession': session_data['services'] = [ AgentVaultInlineService.from_dict(service) for service in data.get('services', []) ] + session_data['metadata'] = data.get('metadata') or {} return super().from_dict(session_data) diff --git a/infisical_sdk/resources/agent_vault.py b/infisical_sdk/resources/agent_vault.py index 612e80a..6da1195 100644 --- a/infisical_sdk/resources/agent_vault.py +++ b/infisical_sdk/resources/agent_vault.py @@ -70,6 +70,16 @@ def _with_services(session: AgentVaultSession) -> AgentVaultSession: return session +class _Unset: + """Marks an argument that wasn't passed, where None has a meaning of its own.""" + + def __repr__(self) -> str: + return "" + + +_UNSET = _Unset() + + def _check_one_user(on_behalf_of_user_email: Optional[str], on_behalf_of_user_id: Optional[str]) -> None: """The API names a user by email address or by ID, not both.""" if on_behalf_of_user_email is not None and on_behalf_of_user_id is not None: @@ -328,6 +338,7 @@ def create( on_behalf_of_user_email: Optional[str] = None, on_behalf_of_user_id: Optional[str] = None, services: Optional[List[Dict[str, Any]]] = None, + metadata: Optional[Dict[str, str]] = None, *, project_id: str) -> CreatedAgentVaultSession: """Create an Agent Vault session with an access bundle you can reach, services of its own, or both, for yourself or, as a machine identity with a delegation, on behalf of a user. @@ -347,6 +358,7 @@ def create( on_behalf_of_user_email: The email address of the user to start the session on behalf of. Can't be combined with on_behalf_of_user_id. on_behalf_of_user_id: The ID of the user to start the session on behalf of. Can't be combined with on_behalf_of_user_email. services: Services the session carries itself, instead of or beside its access bundle's: up to 20 dicts with the API's field names, such as {"type": "http", "hostPattern": "api.github.com", "credential": {"type": "bearer", "value": token}}. Only Agent Vault admins can send them. Each has the same fields as a service in an access bundle, except that its name is optional for HTTP and MCP services (database and SSH services need one), its values can't use variables, and it can't use OAuth or member-provided values. To limit an MCP server to some of its tools, send their names in allowedTools, which needs an Infisical version that accepts a tool list on a session's services. + metadata: Key-value pairs to tag the session with, such as {"runId": "8812"}. Up to 20 keys. A key is 1 to 255 characters and a value up to 1020, without line breaks, tabs, or invisible characters. Keys that match once trimmed are rejected. project_id: The ID of the Agent Vault project to create the session in. Returns: @@ -366,6 +378,7 @@ def create( "services": services, "ttl": ttl, "label": label, + "metadata": metadata, "onBehalfOf": on_behalf_of, "projectId": project_id, } @@ -378,19 +391,25 @@ def create( return result.data.session - def update(self, session_id: str, label: Optional[str]) -> AgentVaultSession: - """Update the label of an Agent Vault session. This also works after the session expires or is revoked. + def update( + self, + session_id: str, + label: Union[str, None, _Unset] = _UNSET, + *, + metadata: Optional[Dict[str, str]] = None) -> AgentVaultSession: + """Update the label or metadata of an Agent Vault session. Pass label, metadata, or both; a value you leave out stays as it is. This also works after the session expires or is revoked, but not once the session's owner, or the user it was started on behalf of, is deleted. Args: session_id: The ID of the session to update. - label: The new label for the session, up to 128 characters, without line breaks, tabs, or invisible characters. Pass None or an empty string to remove the label. You can't change the label once the session's owner, or the user it was started on behalf of, is deleted. + label: The new label for the session, up to 128 characters, without line breaks, tabs, or invisible characters. Pass None or an empty string to remove the label. + metadata: The session's new metadata, which replaces all of it, such as {"runId": "8812"}. Pass {} to remove it. Up to 20 keys. A key is 1 to 255 characters and a value up to 1020, without line breaks, tabs, or invisible characters. Keys that match once trimmed are rejected. Returns: The updated session. """ - request_body = { - "label": label, - } + request_body: Dict[str, Any] = {"metadata": metadata} + if not isinstance(label, _Unset): + request_body["label"] = label result = self.requests.patch( path=f"/api/v1/agent-vault/sessions/{_segment(session_id)}", diff --git a/tests/test_agent_vault.py b/tests/test_agent_vault.py index 9d6450b..81be312 100644 --- a/tests/test_agent_vault.py +++ b/tests/test_agent_vault.py @@ -110,10 +110,45 @@ def test_proxies_update_sends_an_empty_description_to_remove_it(api, agent_vault @pytest.mark.parametrize("label", ["nightly deploy", None]) -def test_sessions_update_always_sends_the_label(api, agent_vault, json_response, label): +def test_sessions_update_sends_a_label_it_is_given(api, agent_vault, json_response, label): api.session.patch.return_value = json_response({"session": dict(SESSION, label=label)}) assert agent_vault.sessions.update(SESSION["id"], label).label == label assert api.session.patch.call_args.kwargs["json"] == {"label": label} + agent_vault.sessions.update(SESSION["id"], label=label) + assert api.session.patch.call_args.kwargs["json"] == {"label": label} + + +@pytest.mark.parametrize("metadata", [{"runId": "8812"}, {}], ids=["set", "clear"]) +def test_sessions_update_sends_only_metadata_and_leaves_the_label(api, agent_vault, json_response, metadata): + api.session.patch.return_value = json_response({"session": dict(SESSION, metadata=metadata)}) + assert agent_vault.sessions.update(SESSION["id"], metadata=metadata).metadata == metadata + assert api.session.patch.call_args.kwargs["json"] == {"metadata": metadata} + + +def test_sessions_update_sends_a_label_and_metadata_together(api, agent_vault, json_response): + api.session.patch.return_value = json_response({"session": SESSION}) + agent_vault.sessions.update(SESSION["id"], None, metadata={"runId": "8812"}) + assert api.session.patch.call_args.kwargs["json"] == {"label": None, "metadata": {"runId": "8812"}} + + +def test_sessions_create_sends_metadata_and_reads_it_back(api, agent_vault, json_response): + metadata = {"runId": "8812", "team": "platform"} + api.session.post.return_value = json_response({"session": dict(SESSION, token="token", metadata=metadata)}) + session = agent_vault.sessions.create(access_bundle="release", metadata=metadata, project_id=PROJECT_ID) + assert api.session.post.call_args.kwargs["json"] == {"accessBundle": "release", "metadata": metadata, "projectId": PROJECT_ID} + assert session.metadata == metadata + + +def test_sessions_get_reads_the_metadata(api, agent_vault, json_response): + api.session.get.return_value = json_response({"session": dict(SESSION, metadata={"runId": "8812"})}) + assert agent_vault.sessions.get(SESSION["id"]).metadata["runId"] == "8812" + + +def test_sessions_without_metadata_read_it_as_empty(api, agent_vault, json_response): + api.session.get.return_value = json_response({"session": SESSION}) + assert agent_vault.sessions.get(SESSION["id"]).metadata == {} + api.session.post.return_value = json_response({"session": dict(SESSION, token="token")}) + assert agent_vault.sessions.create(access_bundle="release", project_id=PROJECT_ID).metadata == {} @pytest.mark.parametrize("create", [ From c910f7c68f34a5ec755da3b3c245eb72d8c99743 Mon Sep 17 00:00:00 2001 From: saif <11242541+saifsmailbox98@users.noreply.github.com> Date: Tue, 17 Nov 2026 02:09:11 +0530 Subject: [PATCH 2/3] ci: pin the test runner to ubuntu-24.04, which still has Python 3.8 and 3.9 --- .github/workflows/python.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 8362599..7ba8ece 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -10,7 +10,7 @@ on: [push, pull_request] jobs: build: - runs-on: ubuntu-latest + runs-on: ubuntu-24.04 strategy: matrix: python-version: ["3.8", "3.9", "3.10", "3.11"] From bb83d74ff7bbd9e827c53d1519c0889efdc5a07c Mon Sep 17 00:00:00 2001 From: saif <11242541+saifsmailbox98@users.noreply.github.com> Date: Tue, 17 Nov 2026 02:56:16 +0530 Subject: [PATCH 3/3] feat(agent-vault): filter the session list by metadata --- infisical_sdk/resources/agent_vault.py | 3 +++ tests/test_agent_vault.py | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/infisical_sdk/resources/agent_vault.py b/infisical_sdk/resources/agent_vault.py index 6da1195..f736718 100644 --- a/infisical_sdk/resources/agent_vault.py +++ b/infisical_sdk/resources/agent_vault.py @@ -276,6 +276,7 @@ def list( search: Optional[str] = None, limit: int = 20, offset: int = 0, + metadata: Optional[Dict[str, str]] = None, *, project_id: str) -> ListAgentVaultSessionsResponse: """List Agent Vault sessions. @@ -286,6 +287,7 @@ def list( search: Match sessions by label, actor name, actor email, the name or email of the user a session was started on behalf of, or access bundle name. limit: The maximum number of sessions to return (1-100). Defaults to 20. offset: How many sessions to skip. Defaults to 0. + metadata: Only return sessions whose metadata matches every one of these key-value pairs exactly, such as {"runId": "8812"}. Up to 20 pairs. project_id: The ID of the Agent Vault project to list sessions from. Returns: @@ -299,6 +301,7 @@ def list( "scope": scope.value if isinstance(scope, AgentVaultSessionScope) else scope, "status": status, "search": search, + "metadata": [f"{key}={value}" for key, value in metadata.items()] if metadata else None, "limit": limit, "offset": offset, "projectId": project_id, diff --git a/tests/test_agent_vault.py b/tests/test_agent_vault.py index 81be312..34cd917 100644 --- a/tests/test_agent_vault.py +++ b/tests/test_agent_vault.py @@ -252,6 +252,26 @@ def test_sessions_get_reads_the_user_a_session_acts_for(api, agent_vault, json_r assert agent_vault.sessions.get(SESSION["id"]).onBehalfOf == expected +def test_sessions_list_sends_each_metadata_pair_as_its_own_metadata_parameter(api, agent_vault, json_response): + api.session.get.return_value = json_response({"sessions": [], "totalCount": 0}) + agent_vault.sessions.list(metadata={"runId": "8812", "env": "prod"}, project_id=PROJECT_ID) + call = api.session.get.call_args + prepared = requests.Request("GET", call.args[0], params=call.kwargs["params"]).prepare() + assert prepared.url == ( + "https://infisical.example.com/api/v1/agent-vault/sessions" + f"?scope=mine&metadata=runId%3D8812&metadata=env%3Dprod&limit=20&offset=0&projectId={PROJECT_ID}" + ) + + +@pytest.mark.parametrize("metadata", [None, {}]) +def test_sessions_list_leaves_out_an_empty_metadata_filter(api, agent_vault, json_response, metadata): + api.session.get.return_value = json_response({"sessions": [], "totalCount": 0}) + agent_vault.sessions.list(metadata=metadata, project_id=PROJECT_ID) + call = api.session.get.call_args + prepared = requests.Request("GET", call.args[0], params=call.kwargs["params"]).prepare() + assert "metadata" not in prepared.url + + def test_access_bundles_list_sends_booleans_the_way_the_api_reads_them(api, agent_vault, json_response): api.session.get.return_value = json_response({"accessBundles": [], "totalCount": 0}) agent_vault.access_bundles.list(requires_setup=True, granted=False, project_id=PROJECT_ID)